use issues::services::boards::{CreateBoardCmd, ListBoardQuery, UpdateBoardCmd};
use issues::services::comments::{CreateCommentCmd, ListCommentQuery, UpdateCommentCmd};
use issues::services::dependencies::CreateDependencyCmd;
use issues::services::issues::{CreateIssueCmd, IssueState, ListIssueQuery, UpdateIssueCmd};
use issues::services::labels::{CreateLabelCmd, ListLabelQuery, UpdateLabelCmd};
use issues::services::members::{CreateIssueMemberCmd, ListIssueMemberQuery};
use issues::services::milestones::{CreateMilestoneCmd, ListMilestoneQuery, UpdateMilestoneCmd};
use issues::services::pins::{CreatePinCmd, UpdatePinCmd};
use models::issue::issue_item::IssuePriority;
use models::issue::issue_member::IssueMemberKind;
use rmcp::model::CallToolResult;
use uuid::Uuid;

use crate::auth::Principal;
use crate::error::{tool_done, tool_error, tool_ok, write_denied};
use crate::services::McpServices;
use crate::tools::args;
use crate::tools::helpers::{parse_enum, parse_time};

async fn resolve_issue(
    services: &McpServices,
    principal: &Principal,
    space: &str,
    board_id: Uuid,
    reference: &str,
) -> Result<Uuid, CallToolResult> {
    services
        .issues
        .resolve_issue_ref(principal.uid, space.trim(), board_id, reference.trim())
        .await
        .map_err(tool_error)
}

pub(crate) async fn board_list(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueBoardListArgs,
) -> CallToolResult {
    let query = ListBoardQuery {
        dir_id: args.dir_id,
        q: args.q,
        limit: args.limit,
        offset: args.offset,
    };
    match services
        .issues
        .list_boards(principal.uid, args.space.trim(), query)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn board_get(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueBoardRefArgs,
) -> CallToolResult {
    match services
        .issues
        .get_board(principal.uid, args.space.trim(), args.board_id)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn board_create(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueBoardCreateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let cmd = CreateBoardCmd {
        name: args.name,
        parent_dir_id: args.parent_dir_id,
        icon: args.icon,
        description: args.description,
    };
    match services
        .issues
        .create_board(principal.uid, args.space.trim(), cmd)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn board_update(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueBoardUpdateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let cmd = UpdateBoardCmd {
        name: args.name,
        icon: args.icon.map(Some),
        description: args.description.map(Some),
    };
    match services
        .issues
        .update_board(principal.uid, args.space.trim(), args.board_id, cmd)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn board_delete(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueBoardRefArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    match services
        .issues
        .delete_board(principal.uid, args.space.trim(), args.board_id)
        .await
    {
        Ok(()) => tool_done(),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn list(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueListArgs,
) -> CallToolResult {
    let state = match args.state.as_deref() {
        Some(raw) => match parse_enum::<IssueState>(raw) {
            Ok(state) => Some(state),
            Err(error) => return error,
        },
        None => None,
    };
    let priority = match args.priority.as_deref() {
        Some(raw) => match parse_enum::<IssuePriority>(raw) {
            Ok(priority) => Some(priority),
            Err(error) => return error,
        },
        None => None,
    };
    let query = ListIssueQuery {
        state,
        author_id: args.author_id,
        milestone_id: args.milestone_id,
        label_id: args.label_id,
        assignee_id: args.assignee_id,
        priority,
        sort: args.sort,
        q: args.q,
        limit: args.limit,
        offset: args.offset,
    };
    match services
        .issues
        .list_issues(principal.uid, args.space.trim(), args.board_id, query)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn get(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueRefArgs,
) -> CallToolResult {
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    match services
        .issues
        .get_issue(principal.uid, args.space.trim(), args.board_id, issue_id)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn create(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueCreateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let priority = match args.priority.as_deref() {
        Some(raw) => match parse_enum::<IssuePriority>(raw) {
            Ok(priority) => priority,
            Err(error) => return error,
        },
        None => IssuePriority::None,
    };
    let due_at = match args.due_at.as_deref() {
        Some(raw) => match parse_time(raw) {
            Ok(time) => Some(time),
            Err(error) => return error,
        },
        None => None,
    };
    let cmd = CreateIssueCmd {
        title: args.title,
        description: args.description,
        content: args.content.unwrap_or_default(),
        milestone_id: args.milestone_id,
        priority,
        due_at,
        assignee_ids: args.assignee_ids,
        label_ids: args.label_ids,
    };
    match services
        .issues
        .create_issue(principal.uid, args.space.trim(), args.board_id, cmd)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn update(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueUpdateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    let priority = match args.priority.as_deref() {
        Some(raw) => match parse_enum::<IssuePriority>(raw) {
            Ok(priority) => Some(priority),
            Err(error) => return error,
        },
        None => None,
    };
    let due_at = match args.due_at.as_deref() {
        Some(raw) => match parse_time(raw) {
            Ok(time) => Some(Some(time)),
            Err(error) => return error,
        },
        None => None,
    };
    let cmd = UpdateIssueCmd {
        title: args.title,
        description: args.description.map(Some),
        content: args.content,
        milestone_id: args.milestone_id.map(Some),
        priority,
        due_at,
        assignee_ids: args.assignee_ids,
        label_ids: args.label_ids,
    };
    match services
        .issues
        .update_issue(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            cmd,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn delete(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueRefArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    match services
        .issues
        .delete_issue(principal.uid, args.space.trim(), args.board_id, issue_id)
        .await
    {
        Ok(()) => tool_done(),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn set_closed(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueRefArgs,
    closed: bool,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    match services
        .issues
        .close_issue(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            closed,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn comment_list(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueCommentListArgs,
) -> CallToolResult {
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    let query = ListCommentQuery {
        parent_id: args.parent_id,
        limit: args.limit,
        offset: args.offset,
        sort: args.sort,
    };
    match services
        .issues
        .list_comments(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            query,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn comment_create(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueCommentCreateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    let cmd = CreateCommentCmd {
        content: args.content,
        parent_id: args.parent_id,
    };
    match services
        .issues
        .create_comment(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            cmd,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn comment_update(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueCommentUpdateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    let cmd = UpdateCommentCmd {
        content: args.content,
    };
    match services
        .issues
        .update_comment(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            args.comment_id,
            cmd,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn comment_delete(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueCommentRefArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    match services
        .issues
        .delete_comment(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            args.comment_id,
        )
        .await
    {
        Ok(()) => tool_done(),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn label_list(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueLabelListArgs,
) -> CallToolResult {
    let query = ListLabelQuery {
        q: args.q,
        is_archived: Some(false),
        limit: args.limit,
        offset: args.offset,
    };
    match services
        .issues
        .list_labels(principal.uid, args.space.trim(), args.board_id, query)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn label_create(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueLabelCreateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let cmd = CreateLabelCmd {
        name: args.name,
        color: args.color,
        exclusive: args.exclusive,
        exclusive_order: None,
        description: args.description,
    };
    match services
        .issues
        .create_label(principal.uid, args.space.trim(), args.board_id, cmd)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn label_update(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueLabelUpdateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let cmd = UpdateLabelCmd {
        name: args.name,
        color: args.color,
        exclusive: args.exclusive,
        exclusive_order: None,
        description: args.description.map(Some),
        is_archived: args.is_archived,
    };
    match services
        .issues
        .update_label(
            principal.uid,
            args.space.trim(),
            args.board_id,
            args.label_id,
            cmd,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn label_delete(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueLabelRefArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    match services
        .issues
        .delete_label(
            principal.uid,
            args.space.trim(),
            args.board_id,
            args.label_id,
        )
        .await
    {
        Ok(()) => tool_done(),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn label_bind(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueLabelBindArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    match services
        .issues
        .bind_label(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            args.label_id,
        )
        .await
    {
        Ok(()) => tool_done(),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn label_unbind(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueLabelBindArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    match services
        .issues
        .unbind_label(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            args.label_id,
        )
        .await
    {
        Ok(()) => tool_done(),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn milestone_list(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueMilestoneListArgs,
) -> CallToolResult {
    let query = ListMilestoneQuery {
        is_closed: args.is_closed,
        q: args.q,
        limit: args.limit,
        offset: args.offset,
    };
    match services
        .issues
        .list_milestones(principal.uid, args.space.trim(), args.board_id, query)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn milestone_create(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueMilestoneCreateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let due_at = match args.due_at.as_deref() {
        Some(raw) => match parse_time(raw) {
            Ok(time) => Some(time),
            Err(error) => return error,
        },
        None => None,
    };
    let cmd = CreateMilestoneCmd {
        name: args.name,
        description: args.description,
        due_at,
    };
    match services
        .issues
        .create_milestone(principal.uid, args.space.trim(), args.board_id, cmd)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn milestone_update(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueMilestoneUpdateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let due_at = match args.due_at.as_deref() {
        Some(raw) => match parse_time(raw) {
            Ok(time) => Some(Some(time)),
            Err(error) => return error,
        },
        None => None,
    };
    let cmd = UpdateMilestoneCmd {
        name: args.name,
        description: args.description.map(Some),
        due_at,
        is_closed: args.is_closed,
    };
    match services
        .issues
        .update_milestone(
            principal.uid,
            args.space.trim(),
            args.board_id,
            args.milestone_id,
            cmd,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn milestone_delete(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueMilestoneRefArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    match services
        .issues
        .delete_milestone(
            principal.uid,
            args.space.trim(),
            args.board_id,
            args.milestone_id,
        )
        .await
    {
        Ok(()) => tool_done(),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn member_list(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueMemberListArgs,
) -> CallToolResult {
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    let query = ListIssueMemberQuery {
        kind: None,
        limit: args.limit,
        offset: args.offset,
    };
    match services
        .issues
        .list_members(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            query,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn member_create(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueMemberCreateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    let kind = match parse_enum::<IssueMemberKind>(&args.kind) {
        Ok(kind) => kind,
        Err(error) => return error,
    };
    let cmd = CreateIssueMemberCmd {
        user_id: args.user_id,
        kind,
    };
    match services
        .issues
        .create_member(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            cmd,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn member_delete(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueMemberRefArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    match services
        .issues
        .delete_member(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            args.member_id,
        )
        .await
    {
        Ok(()) => tool_done(),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn pin_list(
    services: &McpServices,
    principal: &Principal,
    args: args::IssuePinListArgs,
) -> CallToolResult {
    match services
        .issues
        .list_pins(principal.uid, args.space.trim(), args.board_id)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn pin_create(
    services: &McpServices,
    principal: &Principal,
    args: args::IssuePinCreateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    let cmd = CreatePinCmd {
        issue_id,
        pin_order: args.pin_order.unwrap_or(0),
    };
    match services
        .issues
        .create_pin(principal.uid, args.space.trim(), args.board_id, cmd)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn pin_update(
    services: &McpServices,
    principal: &Principal,
    args: args::IssuePinUpdateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let cmd = UpdatePinCmd {
        pin_order: args.pin_order,
    };
    match services
        .issues
        .update_pin(
            principal.uid,
            args.space.trim(),
            args.board_id,
            args.pin_id,
            cmd,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn pin_delete(
    services: &McpServices,
    principal: &Principal,
    args: args::IssuePinRefArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    match services
        .issues
        .delete_pin(principal.uid, args.space.trim(), args.board_id, args.pin_id)
        .await
    {
        Ok(()) => tool_done(),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn dependency_list(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueDependencyListArgs,
) -> CallToolResult {
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    match services
        .issues
        .list_dependencies(principal.uid, args.space.trim(), args.board_id, issue_id)
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn dependency_create(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueDependencyCreateArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    let cmd = CreateDependencyCmd {
        dependency_id: args.dependency_id,
    };
    match services
        .issues
        .create_dependency(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            cmd,
        )
        .await
    {
        Ok(result) => tool_ok(&result),
        Err(error) => tool_error(error),
    }
}

pub(crate) async fn dependency_delete(
    services: &McpServices,
    principal: &Principal,
    args: args::IssueDependencyRefArgs,
) -> CallToolResult {
    if !principal.can_write() {
        return write_denied();
    }
    let issue_id = match resolve_issue(
        services,
        principal,
        &args.space,
        args.board_id,
        &args.issue_id,
    )
    .await
    {
        Ok(id) => id,
        Err(error) => return error,
    };
    match services
        .issues
        .delete_dependency(
            principal.uid,
            args.space.trim(),
            args.board_id,
            issue_id,
            args.dep_id,
        )
        .await
    {
        Ok(()) => tool_done(),
        Err(error) => tool_error(error),
    }
}