//! 想法相关命令

use serde::Deserialize;
use tauri::State;

use df_core::types::{new_id, Priority};
use df_ideas::capture::Idea;
use df_storage::models::{IdeaRecord, ProjectRecord};

use crate::state::AppState;

use super::now_millis;

/// 创建想法入参
#[derive(Debug, Deserialize)]
pub struct CreateIdeaInput {
    pub title: String,
    #[serde(default)]
    pub description: String,
    #[serde(default = "default_priority")]
    pub priority: i32,
    /// 标签 JSON 数组字符串
    pub tags: Option<String>,
    pub source: Option<String>,
}

fn default_priority() -> i32 {
    1
}

/// 列出想法，可选按 status 过滤（指定状态走 query 走白名单索引列，否则全量）
#[tauri::command]
pub async fn list_ideas(
    state: State<'_, AppState>,
    status: Option<String>,
) -> Result<Vec<IdeaRecord>, String> {
    match status {
        Some(s) => state.ideas.query("status", &s).await.map_err(|e| e.to_string()),
        None => state.ideas.list_all().await.map_err(|e| e.to_string()),
    }
}

/// 创建想法，返回完整记录
#[tauri::command]
pub async fn create_idea(
    state: State<'_, AppState>,
    input: CreateIdeaInput,
) -> Result<IdeaRecord, String> {
    let now = now_millis();
    let record = IdeaRecord {
        id: new_id(),
        title: input.title,
        description: input.description,
        status: "draft".to_string(),
        priority: input.priority,
        score: None,
        tags: input.tags,
        source: input.source,
        promoted_to: None,
        ai_analysis: None,
        scores: None,
        created_at: now.clone(),
        updated_at: now,
    };
    state
        .ideas
        .insert(record.clone())
        .await
        .map_err(|e| e.to_string())?;
    Ok(record)
}

/// 更新想法单个字段（字段名走 df-storage 白名单校验）
#[tauri::command]
pub async fn update_idea(
    state: State<'_, AppState>,
    id: String,
    field: String,
    value: String,
) -> Result<bool, String> {
    state
        .ideas
        .update_field(&id, &field, &value)
        .await
        .map_err(|e| e.to_string())
}

/// 删除想法
#[tauri::command]
pub async fn delete_idea(state: State<'_, AppState>, id: String) -> Result<bool, String> {
    state.ideas.delete(&id).await.map_err(|e| e.to_string())
}

/// 将想法晋升为项目 — 复用 df-project 领域逻辑创建项目，回写想法 status=promoted/promoted_to
#[tauri::command]
pub async fn promote_idea(
    state: State<'_, AppState>,
    id: String,
) -> Result<df_ideas::promotion::PromotionResult, String> {
    let record = state
        .ideas
        .get_by_id(&id)
        .await
        .map_err(|e| e.to_string())?
        .ok_or_else(|| format!("想法不存在: {id}"))?;

    if record.promoted_to.is_some() {
        return Err(format!("想法已立项: {}", record.promoted_to.unwrap()));
    }

    // 复用 df-project 领域逻辑构造项目实体（create_from_idea）
    let project = df_project::manager::ProjectManager::create_from_idea(
        record.title.clone(),
        record.description.clone(),
        id.clone(),
    );
    let project_id = project.id.clone();
    let now = now_millis();
    let project_record = ProjectRecord {
        id: project_id.clone(),
        name: project.name,
        description: project.description,
        status: "planning".to_string(),
        idea_id: Some(id.clone()),
        path: None,
        stack: None,
        created_at: now.clone(),
        updated_at: now.clone(),
    };
    state
        .projects
        .insert(project_record)
        .await
        .map_err(|e| e.to_string())?;

    // 回写想法：status=promoted + promoted_to（update_full 单事务覆盖可变字段）
    // 补偿删除:第二步失败时回滚第一步已建的 project,保证最终一致性(非原子,但防项目存留而
    // 想法状态未变的数据不一致)。Repository 方法各自持锁不支持跨 repo 共享事务对象,故选补偿
    // 删除而非真事务(改动最小,工程投入产出比最高)。
    let updated = IdeaRecord {
        status: "promoted".to_string(),
        promoted_to: Some(project_id.clone()),
        updated_at: now,
        ..record
    };
    if let Err(e) = state.ideas.update_full(&updated).await {
        // 回写失败:补偿删除已建项目,避免悬空项目(idea.promoted_to 仍空,可重试立项)
        tracing::error!("想法 {id} 回写失败,补偿删除已建项目 {project_id}: {e}");
        if let Err(del_err) = state.projects.delete(&project_id).await {
            tracing::error!("补偿删除项目 {project_id} 也失败(需人工清理): {del_err}");
        }
        return Err(format!("想法立项回写失败(已回滚项目创建): {}", e));
    }

    Ok(df_ideas::promotion::PromotionResult {
        idea_id: id,
        project_id: project_id,
        promoted: true,
        reason: "手动立项".to_string(),
    })
}

// ============================================================
// 想法评估 — 多维评分 + 对抗式评估
// ============================================================

/// 评估想法：多维评分 + 对抗式评估，结果写回 scores/score/ai_analysis，状态置 pending_review，返回更新后的记录
#[tauri::command]
pub async fn evaluate_idea(
    state: State<'_, AppState>,
    id: String,
) -> Result<IdeaRecord, String> {
    // 取出想法
    let record = state
        .ideas
        .get_by_id(&id)
        .await
        .map_err(|e| e.to_string())?
        .ok_or_else(|| format!("想法不存在: {id}"))?;

    let idea = record_to_idea(&record);

    // 多维评分（0-10，IPC 层 *10 缩放为 0-100）
    let scores = df_ideas::scoring::ScoringEngine::compute_default(&idea);

    // 对抗式评估
    let eval = df_ideas::adversarial::AdversarialEngine::evaluate(&idea)
        .await
        .map_err(|e| e.to_string())?;

    // 组装前端扁平结构（与 Ideas.vue 的 AdversarialEval interface 对齐）
    let positive_strength = eval.positive.confidence;
    let negative_strength = eval.negative.confidence;
    let net_sentiment = positive_strength - negative_strength;
    let recommendation = recommendation_str(&eval.recommendation).to_string();
    let final_score = eval.final_score;
    let analyst_summary = eval.analyst.summary.clone();
    let action_items = action_items_for(&eval.recommendation);
    let positive = serde_json::json!({
        "thesis": eval.positive.thesis,
        "evidence": eval.positive.evidence,
    });
    let negative = serde_json::json!({
        "thesis": eval.negative.thesis,
        "evidence": eval.negative.evidence,
    });

    let ai_analysis = serde_json::json!({
        "positive_strength": positive_strength,
        "negative_strength": negative_strength,
        "net_sentiment": net_sentiment,
        "recommendation": recommendation,
        "final_score": final_score,
        "summary": analyst_summary,
        "action_items": action_items,
        "positive": positive,
        "negative": negative,
        "analyst": { "summary": analyst_summary },
    })
    .to_string();

    // scores JSON：中文维度 key + 0-100 值（前端雷达图直接当百分比用）
    let scores_json = serde_json::json!({
        "可行性": (scores.feasibility * 10.0).round() as i64,
        "影响力": (scores.impact * 10.0).round() as i64,
        "紧急度": (scores.urgency * 10.0).round() as i64,
        "综合": (scores.overall * 10.0).round() as i64,
    })
    .to_string();

    let score_value = (scores.overall * 10.0).round() as i64;

    // 构造完整记录后单次原子写回（update_full 保留 id 与 created_at）
    let updated = IdeaRecord {
        scores: Some(scores_json),
        ai_analysis: Some(ai_analysis),
        score: Some(score_value as f64),
        status: "pending_review".to_string(),
        updated_at: now_millis(),
        ..record
    };
    state
        .ideas
        .update_full(&updated)
        .await
        .map_err(|e| e.to_string())?;

    Ok(updated)
}

/// IdeaRecord → df_ideas::Idea（评估用，status/time 不影响评分）
fn record_to_idea(record: &IdeaRecord) -> Idea {
    let tags: Vec<String> = record
        .tags
        .as_deref()
        .and_then(|t| serde_json::from_str(t).ok())
        .unwrap_or_default();
    Idea {
        id: record.id.clone(),
        title: record.title.clone(),
        description: record.description.clone(),
        status: df_core::types::IdeaStatus::Draft,
        priority: priority_from_i32(record.priority),
        scores: None,
        tags,
        source: record.source.clone(),
        related_ids: Vec::new(),
        created_at: chrono::Utc::now(),
        updated_at: chrono::Utc::now(),
    }
}

/// i32 优先级 → Priority 枚举（与 df-core 枚举值一致：Low=0/Medium=1/High=2/Critical=3）
fn priority_from_i32(p: i32) -> Priority {
    match p {
        0 => Priority::Low,
        2 => Priority::High,
        x if x >= 3 => Priority::Critical,
        _ => Priority::Medium,
    }
}

/// Recommendation → 前端 assessmentLabel 期望的全小写空格分隔（匹配 map key）
fn recommendation_str(r: &df_ideas::adversarial::Recommendation) -> &'static str {
    use df_ideas::adversarial::Recommendation::*;
    match r {
        ImmediateAction => "immediate action",
        Soon => "soon",
        WithResources => "with resources",
        ResearchMore => "research more",
        Monitor => "monitor",
    }
}

/// 行动建议 — 按推荐等级返回
fn action_items_for(r: &df_ideas::adversarial::Recommendation) -> Vec<String> {
    use df_ideas::adversarial::Recommendation::*;
    match r {
        ImmediateAction => vec!["立即组建项目团队".into(), "制定详细执行计划".into(), "分配必要资源".into()],
        Soon => vec!["下周启动项目".into(), "准备资源需求".into(), "制定时间表".into()],
        WithResources => vec!["确认资源预算".into(), "评估 ROI".into(), "制定风险预案".into()],
        ResearchMore => vec!["进行市场调研".into(), "收集用户反馈".into(), "验证技术可行性".into()],
        Monitor => vec!["持续跟踪相关指标".into(), "定期评估进展".into(), "等待更好时机".into()],
    }
}