use std::collections::HashMap;

use api::users::UserDto;
use models::issue::{comment, issue_reactions};
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, Set};
use serde::{Deserialize, Serialize};
use space::SpaceJoinTrigger;
use space::services::join_rules;
use time::OffsetDateTime;
use utoipa::{IntoParams, ToSchema};
use uuid::Uuid;

use crate::errors::IssueError;
use crate::services::service::IssueService;
use crate::share::lookup::{issue_context, require_issue_access};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "snake_case")]
pub enum ReactionScope {
    Issue,
    Comment,
}

#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct ReactionDto {
    pub id: Uuid,
    pub scope: ReactionScope,
    pub target_id: Uuid,
    pub user: Option<UserDto>,
    pub emoji: String,
    pub created_at: OffsetDateTime,
}

#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct ReactionAggDto {
    pub emoji: String,
    pub count: i64,
    pub user_ids: Vec<i64>,
}

#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct CreateReactionCmd {
    pub emoji: String,
}

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

#[derive(Debug, Clone, Deserialize, IntoParams, ToSchema)]
pub struct EmojiQuery {
    pub emoji: String,
}

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

fn aggregate_reactions(rows: Vec<issue_reactions::Model>) -> Vec<ReactionAggDto> {
    let mut groups: HashMap<String, Vec<i64>> = HashMap::new();
    for r in rows {
        groups.entry(r.emoji).or_default().push(r.user_id);
    }
    let mut result = Vec::new();
    for (emoji, mut uids) in groups {
        uids.sort();
        uids.dedup();
        result.push(ReactionAggDto {
            count: uids.len() as i64,
            emoji,
            user_ids: uids,
        });
    }
    result.sort_by(|a, b| a.emoji.cmp(&b.emoji));
    result
}

impl IssueService {
    fn validate_emoji(&self, emoji: &str) -> Result<String, IssueError> {
        let clean = emoji.trim();
        if clean.is_empty() || clean.chars().count() > self.settings.issues.max_reaction_emoji_len {
            return Err(IssueError::BadRequest(
                "emoji is empty or too long".to_string(),
            ));
        }
        Ok(clean.to_string())
    }

    #[tracing::instrument(name = "issues.create_reaction", skip_all, fields(caller = %caller, space = %space_name, board_id = %board_id, issue_id = %issue_id))]
    pub async fn create_reaction(
        &self,
        caller: i64,
        space_name: &str,
        board_id: Uuid,
        issue_id: Uuid,
        cmd: CreateReactionCmd,
    ) -> Result<ReactionDto, IssueError> {
        let (space, _, _) = issue_context(self, caller, space_name, board_id, issue_id).await?;

        let emoji = self.validate_emoji(&cmd.emoji)?;

        let existing = issue_reactions::Entity::find()
            .filter(issue_reactions::Column::IssueId.eq(Some(issue_id)))
            .filter(issue_reactions::Column::UserId.eq(caller))
            .filter(issue_reactions::Column::Emoji.eq(&emoji))
            .one(self.database.read())
            .await?;

        if existing.is_some() {
            return Err(IssueError::Conflict("reaction already exists".to_string()));
        }

        let now = OffsetDateTime::now_utc();
        let row = issue_reactions::ActiveModel {
            id: Set(Uuid::now_v7()),
            issue_id: Set(Some(issue_id)),
            comment_id: Set(None),
            project_id: Set(None),
            user_id: Set(caller),
            emoji: Set(emoji.clone()),
            created_at: Set(now),
        };

        let inserted = row.insert(self.database.write()).await?;
        if let Err(e) = join_rules::apply_space_join_rules(
            &self.access,
            space.id(),
            caller,
            SpaceJoinTrigger::IssueReaction,
            &emoji,
        )
        .await
        {
            tracing::warn!(%e, "space join rule application failed");
        }
        let user_map = self.audience.load_user_briefs(&[caller]).await?;
        let user = user_map.get(&caller).cloned();

        Ok(ReactionDto {
            id: inserted.id,
            scope: ReactionScope::Issue,
            target_id: issue_id,
            user,
            emoji,
            created_at: inserted.created_at,
        })
    }

    #[tracing::instrument(name = "issues.create_comment_reaction", skip_all, fields(caller = %caller, space = %space_name, board_id = %board_id, issue_id = %issue_id, comment_id = %comment_id))]
    pub async fn create_comment_reaction(
        &self,
        caller: i64,
        space_name: &str,
        board_id: Uuid,
        issue_id: Uuid,
        comment_id: Uuid,
        cmd: CreateReactionCmd,
    ) -> Result<ReactionDto, IssueError> {
        let (space, _, _) = issue_context(self, caller, space_name, board_id, issue_id).await?;

        let c = comment::Entity::find_by_id(comment_id)
            .filter(comment::Column::IssueId.eq(Some(issue_id)))
            .one(self.database.read())
            .await?
            .ok_or(IssueError::NotFound)?;

        let emoji = self.validate_emoji(&cmd.emoji)?;

        let existing = issue_reactions::Entity::find()
            .filter(issue_reactions::Column::CommentId.eq(Some(c.id)))
            .filter(issue_reactions::Column::UserId.eq(caller))
            .filter(issue_reactions::Column::Emoji.eq(&emoji))
            .one(self.database.read())
            .await?;

        if existing.is_some() {
            return Err(IssueError::Conflict("reaction already exists".to_string()));
        }

        let now = OffsetDateTime::now_utc();
        let row = issue_reactions::ActiveModel {
            id: Set(Uuid::now_v7()),
            issue_id: Set(None),
            comment_id: Set(Some(c.id)),
            project_id: Set(None),
            user_id: Set(caller),
            emoji: Set(emoji.clone()),
            created_at: Set(now),
        };

        let inserted = row.insert(self.database.write()).await?;
        if let Err(e) = join_rules::apply_space_join_rules(
            &self.access,
            space.id(),
            caller,
            SpaceJoinTrigger::IssueCommentReaction,
            &emoji,
        )
        .await
        {
            tracing::warn!(%e, "space join rule application failed");
        }
        let user_map = self.audience.load_user_briefs(&[caller]).await?;
        let user = user_map.get(&caller).cloned();

        Ok(ReactionDto {
            id: inserted.id,
            scope: ReactionScope::Comment,
            target_id: c.id,
            user,
            emoji,
            created_at: inserted.created_at,
        })
    }

    pub async fn list_reactions(
        &self,
        caller: i64,
        space_name: &str,
        board_id: Uuid,
        issue_id: Uuid,
    ) -> Result<Vec<ReactionAggDto>, IssueError> {
        require_issue_access(self, caller, space_name, board_id, issue_id).await?;

        let rows = issue_reactions::Entity::find()
            .filter(issue_reactions::Column::IssueId.eq(Some(issue_id)))
            .all(self.database.read())
            .await?;

        Ok(aggregate_reactions(rows))
    }

    pub async fn list_comment_reactions(
        &self,
        caller: i64,
        space_name: &str,
        board_id: Uuid,
        issue_id: Uuid,
        comment_id: Uuid,
    ) -> Result<Vec<ReactionAggDto>, IssueError> {
        require_issue_access(self, caller, space_name, board_id, issue_id).await?;

        let _ = comment::Entity::find_by_id(comment_id)
            .filter(comment::Column::IssueId.eq(Some(issue_id)))
            .one(self.database.read())
            .await?
            .ok_or(IssueError::NotFound)?;

        let rows = issue_reactions::Entity::find()
            .filter(issue_reactions::Column::CommentId.eq(Some(comment_id)))
            .all(self.database.read())
            .await?;

        Ok(aggregate_reactions(rows))
    }

    #[tracing::instrument(name = "issues.remove_reaction_by_emoji", skip_all, fields(caller = %caller, space = %space_name, board_id = %board_id, issue_id = %issue_id))]
    pub async fn remove_reaction_by_emoji(
        &self,
        caller: i64,
        space_name: &str,
        board_id: Uuid,
        issue_id: Uuid,
        emoji: &str,
    ) -> Result<(), IssueError> {
        require_issue_access(self, caller, space_name, board_id, issue_id).await?;

        let emoji = self.validate_emoji(emoji)?;
        let row = issue_reactions::Entity::find()
            .filter(issue_reactions::Column::IssueId.eq(Some(issue_id)))
            .filter(issue_reactions::Column::CommentId.is_null())
            .filter(issue_reactions::Column::UserId.eq(caller))
            .filter(issue_reactions::Column::Emoji.eq(&emoji))
            .one(self.database.write())
            .await?
            .ok_or(IssueError::NotFound)?;
        issue_reactions::Entity::delete_by_id(row.id)
            .exec(self.database.write())
            .await?;
        Ok(())
    }

    #[tracing::instrument(name = "issues.remove_comment_reaction_by_emoji", skip_all, fields(caller = %caller, space = %space_name, board_id = %board_id, issue_id = %issue_id, comment_id = %comment_id))]
    pub async fn remove_comment_reaction_by_emoji(
        &self,
        caller: i64,
        space_name: &str,
        board_id: Uuid,
        issue_id: Uuid,
        comment_id: Uuid,
        emoji: &str,
    ) -> Result<(), IssueError> {
        require_issue_access(self, caller, space_name, board_id, issue_id).await?;
        let _ = comment::Entity::find_by_id(comment_id)
            .filter(comment::Column::IssueId.eq(Some(issue_id)))
            .one(self.database.read())
            .await?
            .ok_or(IssueError::NotFound)?;

        let emoji = self.validate_emoji(emoji)?;
        let row = issue_reactions::Entity::find()
            .filter(issue_reactions::Column::CommentId.eq(Some(comment_id)))
            .filter(issue_reactions::Column::UserId.eq(caller))
            .filter(issue_reactions::Column::Emoji.eq(&emoji))
            .one(self.database.write())
            .await?
            .ok_or(IssueError::NotFound)?;
        issue_reactions::Entity::delete_by_id(row.id)
            .exec(self.database.write())
            .await?;
        Ok(())
    }

    #[tracing::instrument(name = "issues.delete_reaction", skip_all, fields(caller = %caller, space = %space_name, board_id = %board_id, issue_id = %issue_id, reaction_id = %reaction_id))]
    pub async fn delete_reaction(
        &self,
        caller: i64,
        space_name: &str,
        board_id: Uuid,
        issue_id: Uuid,
        reaction_id: Uuid,
    ) -> Result<(), IssueError> {
        require_issue_access(self, caller, space_name, board_id, issue_id).await?;

        let r = issue_reactions::Entity::find_by_id(reaction_id)
            .filter(issue_reactions::Column::UserId.eq(caller))
            .one(self.database.read())
            .await?
            .ok_or(IssueError::NotFound)?;

        let allowed = match r.issue_id {
            Some(iid) => iid == issue_id,
            None => match r.comment_id {
                Some(cid) => comment::Entity::find_by_id(cid)
                    .filter(comment::Column::IssueId.eq(Some(issue_id)))
                    .one(self.database.read())
                    .await?
                    .is_some(),
                None => false,
            },
        };
        if !allowed {
            return Err(IssueError::NotFound);
        }

        issue_reactions::Entity::delete_by_id(r.id)
            .exec(self.database.write())
            .await?;

        Ok(())
    }
}