use std::collections::HashMap;

use models::issue::{issue_item, issue_pin, issues, milestone};
use sea_orm::{
    ActiveModelTrait, ColumnTrait, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder,
    QuerySelect, Set, TransactionTrait,
};
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use utoipa::{IntoParams, ToSchema};
use uuid::Uuid;

use crate::errors::IssueError;
use crate::services::service::IssueService;
use crate::share::authz;
use crate::share::lookup::{board_context, lookup_board, space_context};

#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct BoardDto {
    pub id: Uuid,
    pub name: String,
    /// Number prefix for the board's issues (`CAD` renders as `CAD-12`).
    pub prefix: Option<String>,
    pub icon: Option<String>,
    pub color: Option<String>,
    pub description: Option<String>,
    pub position: i64,
    pub open_issues_count: i64,
    pub closed_issues_count: i64,
    pub created_at: OffsetDateTime,
    pub updated_at: Option<OffsetDateTime>,
}

pub type BoardPage = api::pagination::Page<BoardDto>;

#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct CreateBoardCmd {
    pub name: String,
    #[serde(default)]
    pub prefix: Option<String>,
    #[serde(default)]
    pub icon: Option<String>,
    #[serde(default)]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct UpdateBoardCmd {
    #[serde(default)]
    pub name: Option<String>,
    #[serde(default, deserialize_with = "api::serde_patch::deserialize_opt_opt")]
    pub prefix: Option<Option<String>>,
    #[serde(default, deserialize_with = "api::serde_patch::deserialize_opt_opt")]
    pub icon: Option<Option<String>>,
    #[serde(default, deserialize_with = "api::serde_patch::deserialize_opt_opt")]
    pub description: Option<Option<String>>,
    #[serde(default, deserialize_with = "api::serde_patch::deserialize_opt_opt")]
    pub color: Option<Option<String>>,
    #[serde(default)]
    pub position: Option<i64>,
}

#[derive(Debug, Clone, Deserialize, IntoParams, ToSchema)]
#[serde(deny_unknown_fields)]
pub struct ListBoardQuery {
    pub q: Option<String>,
    pub limit: Option<u64>,
    pub offset: Option<u64>,
}

#[derive(Debug, Clone, Deserialize, IntoParams, ToSchema)]
pub struct BoardPath {
    pub space_name: String,
    pub board_id: Uuid,
}

impl IssueService {
    /// `None`/blank clears the prefix; anything else is upper-cased and must
    /// look like a GitLab-style project key (letter first, alphanumeric only).
    fn normalize_board_prefix(&self, raw: &str) -> Result<Option<String>, IssueError> {
        let trimmed = raw.trim();
        if trimmed.is_empty() {
            return Ok(None);
        }
        let prefix = trimmed.to_ascii_uppercase();
        let first_is_letter = prefix.starts_with(|c: char| c.is_ascii_alphabetic());
        let valid = first_is_letter
            && prefix.chars().count() <= self.settings.issues.max_board_prefix_len
            && prefix.chars().all(|c| c.is_ascii_alphanumeric());
        if !valid {
            return Err(IssueError::BadRequest(
                "board prefix must start with a letter and contain only letters and digits"
                    .to_string(),
            ));
        }
        Ok(Some(prefix))
    }

    /// Prefixes address issues (`CAD-12`), so two boards of one space must not
    /// share one — the ambiguity would be permanent in every pasted link.
    async fn board_prefix_taken(
        &self,
        space_id: Uuid,
        prefix: &str,
        exclude_board: Option<Uuid>,
    ) -> Result<bool, IssueError> {
        let mut select = issues::Entity::find()
            .filter(issues::Column::SpaceId.eq(space_id))
            .filter(issues::Column::Prefix.eq(prefix));
        if let Some(board_id) = exclude_board {
            select = select.filter(issues::Column::Id.ne(board_id));
        }
        Ok(select.one(self.database.read()).await?.is_some())
    }

    fn board_dto(
        board: issues::Model,
        open_issues_count: i64,
        closed_issues_count: i64,
    ) -> BoardDto {
        BoardDto {
            id: board.id,
            name: board.name,
            prefix: board.prefix,
            icon: board.icon,
            color: board.color,
            description: board.description,
            position: board.position,
            open_issues_count,
            closed_issues_count,
            created_at: board.created_at,
            updated_at: board.updated_at,
        }
    }

    async fn issue_counts_by_board(
        &self,
        board_ids: &[Uuid],
    ) -> Result<(HashMap<Uuid, i64>, HashMap<Uuid, i64>), IssueError> {
        let mut total_counts = HashMap::new();
        let mut closed_counts = HashMap::new();
        if board_ids.is_empty() {
            return Ok((total_counts, closed_counts));
        }

        let total_rows: Vec<(Uuid, i64)> = issue_item::Entity::find()
            .select_only()
            .column(issue_item::Column::CollectionId)
            .column_as(issue_item::Column::CollectionId.count(), "cnt")
            .filter(issue_item::Column::CollectionId.is_in(board_ids.to_vec()))
            .group_by(issue_item::Column::CollectionId)
            .into_tuple()
            .all(self.database.read())
            .await?;
        for (collection_id, cnt) in total_rows {
            total_counts.insert(collection_id, cnt);
        }

        let closed_rows: Vec<(Uuid, i64)> = issue_item::Entity::find()
            .select_only()
            .column(issue_item::Column::CollectionId)
            .column_as(issue_item::Column::CollectionId.count(), "cnt")
            .filter(issue_item::Column::CollectionId.is_in(board_ids.to_vec()))
            .filter(issue_item::Column::ClosedAt.is_not_null())
            .group_by(issue_item::Column::CollectionId)
            .into_tuple()
            .all(self.database.read())
            .await?;
        for (collection_id, cnt) in closed_rows {
            closed_counts.insert(collection_id, cnt);
        }

        Ok((total_counts, closed_counts))
    }

    async fn build_board_dto(&self, board: issues::Model) -> Result<BoardDto, IssueError> {
        let (total_counts, closed_counts) = self.issue_counts_by_board(&[board.id]).await?;
        let closed_count = closed_counts.get(&board.id).copied().unwrap_or(0);
        let open_count = total_counts.get(&board.id).copied().unwrap_or(0) - closed_count;
        Ok(Self::board_dto(board, open_count, closed_count))
    }

    #[tracing::instrument(name = "issues.create_board", skip_all, fields(caller = %caller, space = %space_name))]
    pub async fn create_board(
        &self,
        caller: i64,
        space_name: &str,
        cmd: CreateBoardCmd,
    ) -> Result<BoardDto, IssueError> {
        let space = space_context(self, caller, space_name).await?;
        authz::require_board_manage(self, &space, caller).await?;

        let name = cmd.name.trim();
        if name.is_empty() || name.chars().count() > self.settings.issues.max_board_name_len {
            return Err(IssueError::BadRequest(
                "board name is empty or too long".to_string(),
            ));
        }

        let prefix = match cmd.prefix.as_deref() {
            Some(raw) => self.normalize_board_prefix(raw)?,
            None => None,
        };
        if let Some(ref prefix) = prefix
            && self.board_prefix_taken(space.id(), prefix, None).await?
        {
            return Err(IssueError::BadRequest(
                "board prefix is already used by another board".to_string(),
            ));
        }

        let position = issues::Entity::find()
            .filter(issues::Column::SpaceId.eq(space.id()))
            .order_by_desc(issues::Column::Position)
            .one(self.database.read())
            .await?
            .map(|row| row.position + 1)
            .unwrap_or(0);

        let board = {
            let txn = self.database.write().begin().await?;
            let now = OffsetDateTime::now_utc();
            let board_row = issues::ActiveModel {
                id: Set(Uuid::now_v7()),
                space_id: Set(space.id()),
                name: Set(name.to_string()),
                prefix: Set(prefix),
                icon: Set(cmd.icon),
                color: Set(None),
                description: Set(cmd.description),
                position: Set(position),
                created_at: Set(now),
                updated_at: Set(None),
            };
            let board = board_row.insert(&txn).await?;
            txn.commit().await?;
            board
        };

        Ok(BoardDto {
            id: board.id,
            name: board.name,
            prefix: board.prefix,
            icon: board.icon,
            color: board.color,
            description: board.description,
            position: board.position,
            open_issues_count: 0,
            closed_issues_count: 0,
            created_at: board.created_at,
            updated_at: board.updated_at,
        })
    }

    pub async fn list_boards(
        &self,
        caller: i64,
        space_name: &str,
        q: ListBoardQuery,
    ) -> Result<BoardPage, IssueError> {
        let space = space_context(self, caller, space_name).await?;

        let (limit, offset) = self.paginate(q.limit, q.offset)?;

        let mut select = issues::Entity::find().filter(issues::Column::SpaceId.eq(space.id()));

        if let Some(ref search) = q.q {
            let kw = search.trim();
            if !kw.is_empty() {
                select = select.filter(issues::Column::Name.contains(kw));
            }
        }

        select = select.order_by_desc(issues::Column::CreatedAt);

        let total = select.clone().count(self.database.read()).await?;
        let rows = select
            .limit(limit)
            .offset(offset)
            .all(self.database.read())
            .await?;

        let board_ids: Vec<Uuid> = rows.iter().map(|b| b.id).collect();
        let (total_counts, closed_counts) = self.issue_counts_by_board(&board_ids).await?;

        let items = rows
            .into_iter()
            .map(|board| {
                let closed_count = closed_counts.get(&board.id).copied().unwrap_or(0);
                let open_count = total_counts.get(&board.id).copied().unwrap_or(0) - closed_count;
                Self::board_dto(board, open_count, closed_count)
            })
            .collect();

        Ok(BoardPage {
            items,
            total,
            limit,
            offset,
        })
    }

    pub async fn get_board(
        &self,
        caller: i64,
        space_name: &str,
        board_id: Uuid,
    ) -> Result<BoardDto, IssueError> {
        let (_, board) = board_context(self, caller, space_name, board_id).await?;
        self.build_board_dto(board).await
    }

    #[tracing::instrument(name = "issues.update_board", skip_all, fields(caller = %caller, space = %space_name, board_id = %board_id))]
    pub async fn update_board(
        &self,
        caller: i64,
        space_name: &str,
        board_id: Uuid,
        cmd: UpdateBoardCmd,
    ) -> Result<BoardDto, IssueError> {
        let space = space_context(self, caller, space_name).await?;
        authz::require_board_manage(self, &space, caller).await?;
        let board = lookup_board(self, &space, board_id, caller).await?;

        let now = OffsetDateTime::now_utc();
        let mut am: issues::ActiveModel = board.clone().into();

        if let Some(new_name) = cmd.name {
            let name = new_name.trim();
            if name.is_empty() || name.chars().count() > self.settings.issues.max_board_name_len {
                return Err(IssueError::BadRequest(
                    "board name is empty or too long".to_string(),
                ));
            }
            am.name = Set(name.to_string());
        }
        if let Some(raw_prefix) = cmd.prefix {
            let prefix = match raw_prefix.as_deref() {
                Some(raw) => self.normalize_board_prefix(raw)?,
                None => None,
            };
            if let Some(ref prefix) = prefix
                && self
                    .board_prefix_taken(space.id(), prefix, Some(board_id))
                    .await?
            {
                return Err(IssueError::BadRequest(
                    "board prefix is already used by another board".to_string(),
                ));
            }
            am.prefix = Set(prefix);
        }
        if let Some(icon) = cmd.icon {
            am.icon = Set(icon);
        }
        if let Some(desc) = cmd.description {
            am.description = Set(desc);
        }
        if let Some(color) = cmd.color {
            am.color = Set(color);
        }
        if let Some(position) = cmd.position {
            if position < 0 {
                return Err(IssueError::BadRequest(
                    "position must be non-negative".to_string(),
                ));
            }
            am.position = Set(position);
        }

        am.updated_at = Set(Some(now));

        let updated = am.update(self.database.write()).await?;

        self.build_board_dto(updated).await
    }

    #[tracing::instrument(name = "issues.delete_board", skip_all, fields(caller = %caller, space = %space_name, board_id = %board_id))]
    pub async fn delete_board(
        &self,
        caller: i64,
        space_name: &str,
        board_id: Uuid,
    ) -> Result<(), IssueError> {
        let space = space_context(self, caller, space_name).await?;
        authz::require_board_manage(self, &space, caller).await?;
        let board = lookup_board(self, &space, board_id, caller).await?;

        self.database
            .primary()
            .transaction::<_, (), IssueError>(|txn| {
                Box::pin(async move {
                    let issue_rows = issue_item::Entity::find()
                        .filter(issue_item::Column::CollectionId.eq(board.id))
                        .all(txn)
                        .await?;

                    issue_pin::Entity::delete_many()
                        .filter(issue_pin::Column::CollectionId.eq(board.id))
                        .exec(txn)
                        .await?;

                    for item in issue_rows {
                        crate::services::issues::delete_issue_cascade_in_txn(txn, item.id).await?;
                    }

                    milestone::Entity::delete_many()
                        .filter(milestone::Column::CollectionId.eq(board.id))
                        .exec(txn)
                        .await?;

                    issues::Entity::delete_by_id(board.id).exec(txn).await?;

                    Ok(())
                })
            })
            .await?;

        Ok(())
    }
}