use oj_rc_factory::{VehicleFactoryAdapter, VehicleInfo, VehicleQueryInfo, VehicleThumbnailInfo, VehicleUploadInfo};
use sea_orm::{ColumnTrait, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder, QuerySelect, sqlx::types::chrono, ActiveModelTrait, TransactionTrait};

pub struct FactoryDatabase {
    orm: std::sync::Arc<sea_orm::DatabaseConnection>,
    cdn: std::sync::Arc<String>,
    upload_duration: std::time::Duration,
}

impl FactoryDatabase {
    pub async fn init(uri: &str, cdn: std::sync::Arc<String>) -> Result<Self, sea_orm::DbErr>{
        let db = sea_orm::Database::connect(uri).await?;
        Ok(Self {
            orm: std::sync::Arc::new(db),
            cdn,
            upload_duration: std::time::Duration::from_secs(365 * 24 * 60 * 60), // 1 year
        })
    }

    pub fn init_preconnected(orm: std::sync::Arc<sea_orm::DatabaseConnection>, cdn: std::sync::Arc<String>) -> Self {
        Self {
            orm,
            cdn,
            upload_duration: std::time::Duration::from_secs(365 * 24 * 60 * 60), // 1 year
        }
    }

    async fn full_vehicle_by_id(&self, id: i32) -> Result<Option<(crate::schema::factory::vehicle::Model, crate::schema::user::Model)>, sea_orm::DbErr> {
        Ok(crate::schema::factory::vehicle::Entity::find_by_id(id)
            .find_also_related(crate::schema::user::Entity)
            .one(self.orm.as_ref())
            .await?
            .and_then(|(vehicle, user_opt)| user_opt.map(|user| (vehicle, user))))
    }

    async fn list_query(&self, query: libfj::robocraft::ListQuery) -> Result<Vec<(crate::schema::factory::vehicle_query::VehicleInfo, crate::schema::factory::vehicle_query::VehicleOwnerInfo)>, sea_orm::DbErr> {
        let mut query_builder = crate::schema::factory::vehicle::Entity::find()
            .filter(crate::schema::factory::vehicle::Column::RemovedDate.is_null())
            .filter(crate::schema::factory::vehicle::Column::BanDate.is_null())
            .filter(crate::schema::factory::vehicle::Column::Buyable.eq(true));

        match query.order {
            libfj::robocraft::FactoryOrderType::Suggested => { query_builder = query_builder.order_by_desc(crate::schema::factory::vehicle::Column::GetCount); },
            libfj::robocraft::FactoryOrderType::CombatRating => { query_builder = query_builder.order_by_desc(crate::schema::factory::vehicle::Column::CombatRating); },
            libfj::robocraft::FactoryOrderType::CosmeticRating => { query_builder = query_builder.order_by_desc(crate::schema::factory::vehicle::Column::CosmeticRating); },
            libfj::robocraft::FactoryOrderType::Added => { query_builder = query_builder.order_by_desc(crate::schema::factory::vehicle::Column::AddedTime); },
            libfj::robocraft::FactoryOrderType::CPU => { query_builder = query_builder.order_by_desc(crate::schema::factory::vehicle::Column::Cpu); },
            libfj::robocraft::FactoryOrderType::MostBought => { query_builder = query_builder.order_by_desc(crate::schema::factory::vehicle::Column::GetCount); },
        }

        if !query.text_filter.is_empty() {
            let query_text = format!("%{}%", query.text_filter.replace('%', ""));
            if query.player_filter {
                query_builder = query_builder.filter(
                    sea_orm::sea_query::Condition::any()
                        .add(crate::schema::user::Column::PublicId.like(query_text.clone()))
                        .add(crate::schema::user::Column::DisplayName.like(query_text))
                );
            } else {
                match query.text_search_field {
                    libfj::robocraft::FactoryTextSearchField::All => {
                        query_builder = query_builder.filter(
                            sea_orm::sea_query::Condition::any()
                                .add(crate::schema::user::Column::PublicId.like(query_text.clone()))
                                .add(crate::schema::user::Column::DisplayName.like(query_text.clone()))
                                .add(crate::schema::factory::vehicle::Column::Name.like(query_text.clone()))
                                .add(crate::schema::factory::vehicle::Column::Description.like(query_text))
                        );
                    },
                    libfj::robocraft::FactoryTextSearchField::Name => {
                        query_builder = query_builder.filter(
                            sea_orm::sea_query::Condition::any()
                                .add(crate::schema::factory::vehicle::Column::Name.like(query_text.clone()))
                        );
                    },
                    libfj::robocraft::FactoryTextSearchField::Player => {
                        query_builder = query_builder.filter(
                            sea_orm::sea_query::Condition::any()
                                .add(crate::schema::user::Column::PublicId.like(query_text.clone()))
                                .add(crate::schema::user::Column::DisplayName.like(query_text))
                        );
                    },
                }
            }
        }
        // TODO support movement and weapon filters
        if query.minimum_cpu > 0 {
            query_builder = query_builder.filter(crate::schema::factory::vehicle::Column::Cpu.gte(query.minimum_cpu as u32));
        }
        if query.maximum_cpu < usize::MAX {
            query_builder = query_builder.filter(crate::schema::factory::vehicle::Column::Cpu.lte(query.maximum_cpu as u32));
        }

        let query_builder = query_builder
            .find_also_related(crate::schema::user::Entity)
            .select_only()
            // WARNING: jank sea_orm query generation (fix)
            .column_as(crate::schema::factory::vehicle::Column::Id, "A_id")
            .column_as(crate::schema::factory::vehicle::Column::UserId, "A_user_id")
            .column_as(crate::schema::factory::vehicle::Column::CreationTime, "A_creation_time")
            .column_as(crate::schema::factory::vehicle::Column::Name, "A_name")
            .column_as(crate::schema::factory::vehicle::Column::Description, "A_description")
            .column_as(crate::schema::factory::vehicle::Column::AddedTime, "A_added_time")
            .column_as(crate::schema::factory::vehicle::Column::ExpiryTime, "A_expiry_time")
            .column_as(crate::schema::factory::vehicle::Column::Cpu, "A_cpu")
            .column_as(crate::schema::factory::vehicle::Column::TotalRobotRanking, "A_total_robot_ranking")
            .column_as(crate::schema::factory::vehicle::Column::GetCount, "A_get_count")
            .column_as(crate::schema::factory::vehicle::Column::Buyable, "A_buyable")
            .column_as(crate::schema::factory::vehicle::Column::RemovedDate, "A_removed_date")
            .column_as(crate::schema::factory::vehicle::Column::BanDate, "A_ban_date")
            .column_as(crate::schema::factory::vehicle::Column::Featured, "A_featured")
            .column_as(crate::schema::factory::vehicle::Column::BannerMessage, "A_banner_message")
            .column_as(crate::schema::factory::vehicle::Column::CombatRating, "A_combat_rating")
            .column_as(crate::schema::factory::vehicle::Column::CosmeticRating, "A_cosmetic_rating")
            .column_as(crate::schema::factory::vehicle::Column::CubeAmounts, "A_cube_amounts")
            .column_as(crate::schema::user::Column::PublicId, "B_public_id")
            .column_as(crate::schema::user::Column::DisplayName, "B_display_name")
            .into_model::<crate::schema::factory::vehicle_query::VehicleInfo, crate::schema::factory::vehicle_query::VehicleOwnerInfo>();
            //.into_partial_model::<crate::schema::factory::vehicle_query::VehicleInfo, crate::schema::factory::vehicle_query::VehicleOwnerInfo>();
        let pagination = query_builder.paginate(self.orm.as_ref(), query.page_size as u64);
        Ok(pagination.fetch_page((query.page - 1) as u64).await?
            .into_iter()
            .filter_map(|(vehicle, user_opt)| user_opt.map(|user| (vehicle, user)))
            .collect())
    }

    fn thumbnail_url(&self, id: i32) -> String {
        format!("{}/roboshop/Live/{}", self.cdn, id)
    }

    fn calculate_cube_amounts(&self, data: &[u8]) -> String {
        let mut counts: std::collections::HashMap<u32, u32> = std::collections::HashMap::new();
        let data = &data[4..];
        for chunk in data.chunks_exact(8) {
            let id_bytes: [u8; 4] = chunk[0..4].try_into().unwrap();
            let part_id = u32::from_le_bytes(id_bytes);

            *counts.entry(part_id).or_insert(0) += 1;
        }
        let mut str_map: std::collections::HashMap<String, u32> = std::collections::HashMap::new();
        for (k, v) in counts {
            str_map.insert(k.to_string(), v);
        }

        serde_json::to_string(&str_map).unwrap_or_else(|_| "{}".to_string())
    }
}

#[async_trait::async_trait]
impl VehicleFactoryAdapter for FactoryDatabase {
    async fn vehicle(&self, id: i32) -> Result<Option<(VehicleInfo, VehicleQueryInfo)>, Box<dyn std::error::Error>> {
        let entities = self.full_vehicle_by_id(id).await?;
        Ok(entities.map(|(vehicle, user)| (
            VehicleInfo {
                id,
                cube_data: vehicle.cube_data,
                colour_data: vehicle.colour_data,
            },
            VehicleQueryInfo {
                id,
                name: vehicle.name,
                description: vehicle.description,
                thumbnail: self.thumbnail_url(id),
                added_by: user.public_id,
                added_by_display_name: user.display_name,
                added_date: vehicle.added_time.and_utc(),
                expiry_date: vehicle.expiry_time.and_utc(),
                cpu: vehicle.cpu as _,
                total_robot_ranking: vehicle.total_robot_ranking as _,
                rent_count: vehicle.get_count as _,
                buy_count: vehicle.get_count as _,
                removed_date: vehicle.removed_date.map(|t| t.and_utc()),
                ban_date: vehicle.ban_date.map(|t| t.and_utc()),
                featured: vehicle.featured,
                buyable: vehicle.buyable,
                banner_message: vehicle.banner_message,
                combat_rating: vehicle.combat_rating,
                cosmetic_rating: vehicle.cosmetic_rating,
                cube_amounts: serde_json::from_str(&vehicle.cube_amounts).unwrap_or_default(),
            },
        )))
    }

    async fn list(&self, query: libfj::robocraft::ListQuery) -> Result<Vec<VehicleQueryInfo>, Box<dyn std::error::Error>> {
        let entities = self.list_query(query).await?;
        Ok(entities.into_iter().map(|(vehicle, user)| VehicleQueryInfo {
            id: vehicle.id,
            name: vehicle.name,
            description: vehicle.description,
            thumbnail: self.thumbnail_url(vehicle.id),
            added_by: user.public_id,
            added_by_display_name: user.display_name,
            added_date: vehicle.added_time.and_utc(),
            expiry_date: vehicle.expiry_time.and_utc(),
            cpu: vehicle.cpu as _,
            total_robot_ranking: vehicle.total_robot_ranking as _,
            rent_count: vehicle.get_count as _,
            buy_count: vehicle.get_count as _,
            removed_date: vehicle.removed_date.map(|t| t.and_utc()),
            ban_date: vehicle.ban_date.map(|t| t.and_utc()),
            featured: vehicle.featured,
            buyable: vehicle.buyable,
            banner_message: vehicle.banner_message,
            combat_rating: vehicle.combat_rating,
            cosmetic_rating: vehicle.cosmetic_rating,
            cube_amounts: serde_json::from_str(&vehicle.cube_amounts).unwrap_or_default(),
        }).collect())
    }

    async fn upload(&self, vehicle: VehicleUploadInfo) -> Result<VehicleThumbnailInfo, Box<dyn std::error::Error>> {
        let now = chrono::Utc::now();
        let entity = crate::schema::factory::vehicle::ActiveModel {
            id: sea_orm::ActiveValue::NotSet,
            user_id: sea_orm::ActiveValue::Set(vehicle.added_by_id),
            garage_id: sea_orm::ActiveValue::Set(vehicle.garage_id),
            creation_time: sea_orm::ActiveValue::Set(now.timestamp()),
            name: sea_orm::ActiveValue::Set(vehicle.name),
            description: sea_orm::ActiveValue::Set(vehicle.description),
            added_time: sea_orm::ActiveValue::Set(now.naive_utc()),
            expiry_time: sea_orm::ActiveValue::Set((now + self.upload_duration).naive_utc()),
            cpu: sea_orm::ActiveValue::Set(vehicle.cpu as i32),
            total_robot_ranking: sea_orm::ActiveValue::Set(vehicle.total_robot_ranking as i32),
            get_count: sea_orm::ActiveValue::Set(0),
            buyable: sea_orm::ActiveValue::Set(true),
            removed_date: sea_orm::ActiveValue::Set(None),
            ban_date: sea_orm::ActiveValue::Set(None),
            featured: sea_orm::ActiveValue::Set(false),
            banner_message: sea_orm::ActiveValue::Set(None),
            combat_rating: sea_orm::ActiveValue::Set(2.5),
            cosmetic_rating: sea_orm::ActiveValue::Set(2.5),
            cube_amounts: sea_orm::ActiveValue::Set(self.calculate_cube_amounts(&vehicle.cube_data)),
            cube_data: sea_orm::ActiveValue::Set(vehicle.cube_data),
            colour_data: sea_orm::ActiveValue::Set(vehicle.colour_data),
        };
        let saved_entity = entity.insert(self.orm.as_ref()).await?;
        Ok(VehicleThumbnailInfo {
            id: saved_entity.id,
            thumbnail: vehicle.thumbnail,
            needs_upload: true,
        })
    }

    async fn rate_vehicle(&self, id: i32, combat: i32, cosmetic: i32) -> Result<(), Box<dyn std::error::Error>> {
        let result = self.orm.as_ref().transaction::<'_, '_, _, (), sea_orm::DbErr>(|txn| {
            Box::pin(async move {
                let select_q = crate::schema::factory::vehicle::Entity::find_by_id(id)
                    .select_only()
                    .columns([
                        crate::schema::factory::vehicle::Column::CombatRating,
                        crate::schema::factory::vehicle::Column::CosmeticRating,
                        crate::schema::factory::vehicle::Column::GetCount,
                    ])
                    .into_tuple::<(f64, f64, i32)>();
                if let Some((curr_combat_rating, curr_cosmetic_rating, get_count)) = select_q.one(txn).await? {
                    let get_count = get_count.clamp(1, 100) as f64;
                    let next_combat_rating = curr_combat_rating + (((combat as f64) - curr_combat_rating) / get_count);
                    let next_cosmetic_rating = curr_cosmetic_rating + (((cosmetic as f64) - curr_cosmetic_rating) / get_count);
                    crate::schema::factory::vehicle::ActiveModel {
                        id: sea_orm::ActiveValue::Set(id),
                        cosmetic_rating: sea_orm::ActiveValue::Set(next_cosmetic_rating),
                        combat_rating: sea_orm::ActiveValue::Set(next_combat_rating),
                        ..Default::default()
                    }.update(txn).await?;
                }
                Ok(())
            })
        }).await;
        if let Err(e) = result {
            return match e {
                sea_orm::TransactionError::Connection(x) => Err(x.into()),
                sea_orm::TransactionError::Transaction(x) => Err(x.into()),
            };
        }
        Ok(())
    }

    /// Just update any purchase trackers
    async fn purchase(&self, id: i32) -> Result<(), Box<dyn std::error::Error>> {
        crate::schema::factory::vehicle::Entity::update_many()
            .col_expr(crate::schema::factory::vehicle::Column::GetCount, crate::schema::factory::vehicle::Column::GetCount.into_expr().add(1))
            .filter(crate::schema::factory::vehicle::Column::Id.eq(id))
            .exec(self.orm.as_ref()).await?;
        Ok(())
    }

    async fn update_vehicle(&self, id: i32, cube_data: Option<Vec<u8>>, colour_data: Option<Vec<u8>>) -> Result<(), Box<dyn std::error::Error>> {
        let cube_amounts = if let Some(cube_data) = &cube_data {
            sea_orm::ActiveValue::Set(self.calculate_cube_amounts(cube_data))
        } else {
            sea_orm::ActiveValue::NotSet
        };
        let result = self.orm.as_ref().transaction::<'_, '_, _, (), sea_orm::DbErr>(|txn| {
            Box::pin(async move {
                let select_q = crate::schema::factory::vehicle::Entity::find_by_id(id)
                    .select_only()
                    .columns([
                        crate::schema::factory::vehicle::Column::Id,
                    ]);
                if select_q.count(txn).await? == 1 {
                    let mut to_update = crate::schema::factory::vehicle::ActiveModel {
                        id: sea_orm::ActiveValue::Set(id),
                        cube_amounts,
                        ..Default::default()
                    };
                    if let Some(cube_data) = cube_data {
                        to_update.cube_data = sea_orm::ActiveValue::Set(cube_data);
                    }
                    if let Some(colour_data) = colour_data {
                        to_update.colour_data = sea_orm::ActiveValue::Set(colour_data);
                    }
                    to_update.update(txn).await?;
                }
                Ok(())
            })
        }).await;
        if let Err(e) = result {
            return match e {
                sea_orm::TransactionError::Connection(x) => Err(x.into()),
                sea_orm::TransactionError::Transaction(x) => Err(x.into()),
            };
        }
        Ok(())
    }

    async fn remove_vehicle(&self, id: i32, user_id: i32) -> Result<(), Box<dyn std::error::Error>> {
        let now = chrono::Utc::now();
        let result = self.orm.as_ref().transaction::<'_, '_, _, (), sea_orm::DbErr>(|txn| {
            Box::pin(async move {
                let select_q = crate::schema::factory::vehicle::Entity::find_by_id(id)
                    .select_only()
                    .columns([
                        crate::schema::factory::vehicle::Column::Id,
                        crate::schema::factory::vehicle::Column::UserId,
                    ])
                    .into_tuple::<(i32, i32)>();
                if let Some((_selected_id, selected_user_id)) = select_q.one(txn).await? {
                    if selected_user_id != user_id {
                        //log::warn!("User {} tried to remove factory vehicle owned by {}", user_id, selected_user_id);
                        return Ok(());
                    }
                    crate::schema::factory::vehicle::ActiveModel {
                        id: sea_orm::ActiveValue::Set(id),
                        buyable: sea_orm::ActiveValue::Set(false),
                        removed_date: sea_orm::ActiveValue::Set(Some(now.naive_utc())),
                        ..Default::default()
                    }.update(txn).await?;
                }
                Ok(())
            })
        }).await;
        if let Err(e) = result {
            return match e {
                sea_orm::TransactionError::Connection(x) => Err(x.into()),
                sea_orm::TransactionError::Transaction(x) => Err(x.into()),
            };
        }
        Ok(())
    }

    async fn set_featured(&self, id: i32, is_featured: bool) -> Result<(), Box<dyn std::error::Error>> {
        crate::schema::factory::vehicle::ActiveModel {
            id: sea_orm::ActiveValue::Set(id),
            featured: sea_orm::ActiveValue::Set(is_featured),
            ..Default::default()
        }.update(self.orm.as_ref()).await?;
        Ok(())
    }
}