use db::conn::sea_orm::IntoActiveModel;
use db::project::project as project_entity;
use db::project::project_activities as activity_entity;
use db::project::project_members as member_entity;
use db::project::project_members::ProjectMemberRole;
use db::project::project_state::ProjectState as DbState;
use sea_orm::{ActiveModelTrait, Set};
use time::OffsetDateTime;
use uuid::Uuid;

use crate::error::{ProjectError, ProjectResult};
use crate::features::ProjectService;
use crate::permission;

use super::{
    CreateProjectCmd, ListProjectQuery, ProjectPage, ProjectView, UpdateProjectCmd,
};

pub async fn create_project(
    svc: &ProjectService,
    actor: Uuid,
    cmd: CreateProjectCmd,
) -> ProjectResult<ProjectView> {
    let perms =
        crate::features::authz::resolve(svc, actor, cmd.space_id, Uuid::nil()).await?;
    perms.require(permission::VIEW_PROJECT).map_err(|a| {
        ProjectError::Forbidden(format!("caller not authorized: missing {a}"))
    })?;

    let id = Uuid::new_v4();
    let now = OffsetDateTime::now_utc();
    let model = project_entity::ActiveModel {
        id: Set(id),
        space_id: Set(cmd.space_id),
        creator_id: Set(actor),
        name: Set(cmd.name),
        description: Set(cmd.description),
        lead_id: Set(cmd.lead_id),
        icon: Set(cmd.icon),
        color: Set(cmd.color),
        state: Set(DbState::Backlog),
        target_date: Set(cmd.target_date),
        started_at: Set(None),
        completed_at: Set(None),
        cancelled_at: Set(None),
        health: Set(None),
        sort_order: Set(0),
        starred: Set(0),
        created_at: Set(now),
        updated_at: Set(None),
    };
    let inserted = model.insert(&svc.db.writer()).await?;

    let _ = member_entity::ActiveModel {
        id: Set(Uuid::new_v4()),
        project_id: Set(id),
        user_id: Set(actor),
        role: Set(ProjectMemberRole::Owner),
        joined_at: Set(now),
        updated_at: Set(None),
    }
    .insert(&svc.db.writer())
    .await?;

    log_activity(svc, id, actor, "created", "self", None, None).await;

    Ok(view_from(&inserted))
}

pub async fn get_project(
    svc: &ProjectService,
    actor: Uuid,
    space_id: Uuid,
    project_id: Uuid,
) -> ProjectResult<ProjectView> {
    crate::features::authz::require(svc, actor, space_id, project_id, permission::VIEW_PROJECT)
        .await?;
    use db::conn::sea_orm::EntityTrait;
    let row = project_entity::Entity::find_by_id(project_id)
        .one(&svc.db.reader())
        .await?
        .ok_or_else(|| ProjectError::NotFound(format!("project {project_id}")))?;
    Ok(view_from(&row))
}

pub async fn list_projects(
    svc: &ProjectService,
    actor: Uuid,
    q: ListProjectQuery,
) -> ProjectResult<ProjectPage> {
    crate::features::authz::resolve(svc, actor, q.space_id, Uuid::nil()).await?;
    let page = q.page.max(1);
    let per_page = q.per_page.clamp(1, svc.config.max_page_size);
    let offset = (page - 1) * per_page;

    use db::conn::sea_orm::{ColumnTrait, EntityTrait, QueryFilter, QueryOrder, PaginatorTrait};
    let mut query = project_entity::Entity::find()
        .filter(project_entity::Column::SpaceId.eq(q.space_id))
        .order_by_asc(project_entity::Column::SortOrder)
        .order_by_desc(project_entity::Column::CreatedAt);

    if let Some(state) = q.state {
        query = query.filter(project_entity::Column::State.eq(state as i32));
    }
    if let Some(lead) = q.lead_id {
        query = query.filter(project_entity::Column::LeadId.eq(lead));
    }

    let reader = svc.db.reader();
    let paginator = query.paginate(&reader, per_page);
    let total = paginator.num_items().await?;
    let rows = paginator.fetch_page(offset / per_page).await?;
    let items = rows.iter().map(view_from).collect();
    Ok(ProjectPage { total, items })
}

pub async fn update_project(
    svc: &ProjectService,
    actor: Uuid,
    space_id: Uuid,
    project_id: Uuid,
    cmd: UpdateProjectCmd,
) -> ProjectResult<ProjectView> {
    crate::features::authz::require(svc, actor, space_id, project_id, permission::EDIT_PROJECT)
        .await?;

    let current = {
        use db::conn::sea_orm::EntityTrait;
        project_entity::Entity::find_by_id(project_id)
            .one(&svc.db.reader())
            .await?
            .ok_or_else(|| ProjectError::NotFound(format!("project {project_id}")))?
    };

    let mut active: project_entity::ActiveModel = current.into_active_model();
    if let Some(name) = cmd.name {
        active.name = Set(name);
    }
    if let Some(desc) = cmd.description {
        active.description = Set(Some(desc));
    }
    if cmd.lead_id.is_some() {
        active.lead_id = Set(cmd.lead_id);
    }
    if cmd.icon.is_some() {
        active.icon = Set(cmd.icon);
    }
    if cmd.color.is_some() {
        active.color = Set(cmd.color);
    }
    if let Some(state) = cmd.state {
        apply_state_transition(&mut active, state);
    }
    if cmd.target_date.is_some() {
        active.target_date = Set(cmd.target_date);
    }
    if let Some(h) = cmd.health {
        let db_h = match h {
            crate::features::lifecycle::ProjectHealth::OnTrack => {
                Some(db::project::project_health::ProjectHealth::OnTrack)
            }
            crate::features::lifecycle::ProjectHealth::AtRisk => {
                Some(db::project::project_health::ProjectHealth::AtRisk)
            }
            crate::features::lifecycle::ProjectHealth::OffTrack => {
                Some(db::project::project_health::ProjectHealth::OffTrack)
            }
            crate::features::lifecycle::ProjectHealth::None => None,
        };
        active.health = Set(db_h);
    }
    if let Some(so) = cmd.sort_order {
        active.sort_order = Set(so);
    }
    active.updated_at = Set(Some(OffsetDateTime::now_utc()));

    let updated = active.update(&svc.db.writer()).await?;
    let _ = svc.cache.invalidate_project(project_id).await;

    log_activity(svc, project_id, actor, "updated", "self", None, None).await;
    Ok(view_from(&updated))
}

pub async fn delete_project(
    svc: &ProjectService,
    actor: Uuid,
    space_id: Uuid,
    project_id: Uuid,
) -> ProjectResult<()> {
    crate::features::authz::require(
        svc,
        actor,
        space_id,
        project_id,
        permission::DELETE_PROJECT,
    )
    .await?;
    use db::conn::sea_orm::EntityTrait;
    project_entity::Entity::delete_by_id(project_id)
        .exec(&svc.db.writer())
        .await?;
    let _ = svc.cache.invalidate_project(project_id).await;
    Ok(())
}

fn apply_state_transition(
    active: &mut project_entity::ActiveModel,
    new: super::ProjectState,
) {
    let now = OffsetDateTime::now_utc();
    let now_db = match new {
        super::ProjectState::InProgress => DbState::InProgress,
        super::ProjectState::Paused => DbState::Paused,
        super::ProjectState::Planned => DbState::Planned,
        super::ProjectState::Backlog => DbState::Backlog,
        super::ProjectState::Completed => DbState::Completed,
        super::ProjectState::Cancelled => DbState::Cancelled,
    };
    active.state = Set(now_db);
    match now_db {
        DbState::InProgress => active.started_at = Set(Some(now)),
        DbState::Completed => active.completed_at = Set(Some(now)),
        DbState::Cancelled => active.cancelled_at = Set(Some(now)),
        _ => {}
    }
}

pub async fn log_activity(
    svc: &ProjectService,
    project_id: Uuid,
    actor: Uuid,
    verb: &str,
    target_kind: &str,
    target_id: Option<Uuid>,
    payload: Option<serde_json::Value>,
) {
    let _ = activity_entity::ActiveModel {
        id: Set(Uuid::new_v4()),
        project_id: Set(project_id),
        actor_id: Set(actor),
        verb: Set(verb.to_string()),
        target_kind: Set(target_kind.to_string()),
        target_id: Set(target_id),
        payload: Set(payload),
        created_at: Set(OffsetDateTime::now_utc()),
    }
    .insert(&svc.db.writer())
    .await;
}

pub fn view_from(m: &project_entity::Model) -> ProjectView {
    ProjectView {
        id: m.id,
        space_id: m.space_id,
        creator_id: m.creator_id,
        lead_id: m.lead_id,
        name: m.name.clone(),
        description: m.description.clone(),
        icon: m.icon.clone(),
        color: m.color.clone(),
        state: m.state.into(),
        target_date: m.target_date,
        started_at: m.started_at,
        completed_at: m.completed_at,
        cancelled_at: m.cancelled_at,
        health: m.health.into(),
        sort_order: m.sort_order,
        starred: m.starred,
        created_at: m.created_at,
        updated_at: m.updated_at,
    }
}