//! Refactor item MCP tools.

#![allow(unused_imports, dead_code)]
#[allow(unused_imports)]
use crate::agents::{
    close_bug_to_archive, feature_branch_has_unmerged_changes, move_story_to_done,
};
use crate::http::context::AppContext;
use crate::http::workflow::{
    add_criterion_to_file, check_criterion_in_file, create_bug_file, create_refactor_file,
    create_spike_file, create_story_file, edit_criterion_in_file, list_bug_files,
    list_refactor_files, load_pipeline_state, load_upcoming_stories, remove_criterion_from_file,
    update_story_in_file, validate_story_dirs,
};
use crate::io::story_metadata::parse_unchecked_todos;
use crate::service::story::parse_test_cases;
use crate::slog_warn;
#[allow(unused_imports)]
use crate::workflow::{TestCaseResult, TestStatus, evaluate_acceptance_with_coverage};
use serde_json::{Value, json};
use std::collections::HashMap;
use std::fs;

pub(crate) fn tool_create_refactor(args: &Value, ctx: &AppContext) -> Result<String, String> {
    let name = args
        .get("name")
        .and_then(|v| v.as_str())
        .ok_or("Missing required argument: name")?;
    let description = args.get("description").and_then(|v| v.as_str());
    let acceptance_criteria: Vec<String> = args
        .get("acceptance_criteria")
        .and_then(|v| serde_json::from_value(v.clone()).ok())
        .ok_or("Missing required argument: acceptance_criteria")?;
    if acceptance_criteria.is_empty() {
        return Err("acceptance_criteria must contain at least one entry".to_string());
    }
    const JUNK_AC: &[&str] = &["", "todo", "tbd", "fixme", "xxx", "???"];
    let all_junk = acceptance_criteria
        .iter()
        .all(|ac| JUNK_AC.contains(&ac.trim().to_lowercase().as_str()));
    if all_junk {
        return Err(
            "acceptance_criteria must contain at least one real entry (not just TODO/TBD/FIXME/XXX/???)."
                .to_string(),
        );
    }
    let depends_on: Option<Vec<u32>> = args
        .get("depends_on")
        .and_then(|v| serde_json::from_value(v.clone()).ok());

    let root = ctx.state.get_project_root()?;
    let refactor_id = create_refactor_file(
        &root,
        name,
        description,
        &acceptance_criteria,
        depends_on.as_deref(),
    )?;

    Ok(format!("Created refactor: {refactor_id}"))
}

pub(crate) fn tool_list_refactors(ctx: &AppContext) -> Result<String, String> {
    let root = ctx.state.get_project_root()?;
    let refactors = list_refactor_files(&root)?;
    serde_json::to_string_pretty(&json!(
        refactors
            .iter()
            .map(|(id, name)| json!({ "refactor_id": id, "name": name }))
            .collect::<Vec<_>>()
    ))
    .map_err(|e| format!("Serialization error: {e}"))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::http::test_helpers::test_ctx;
    use serde_json::json;

    #[test]
    fn tool_create_refactor_rejects_whitespace_only_name() {
        let tmp = tempfile::tempdir().unwrap();
        let ctx = test_ctx(tmp.path());
        let err = tool_create_refactor(
            &json!({"name": "   ", "acceptance_criteria": ["Code is clean"]}),
            &ctx,
        )
        .unwrap_err();
        assert!(
            err.contains("empty") || err.contains("whitespace"),
            "error should mention empty/whitespace, got: {err}"
        );
    }

    #[test]
    fn tool_create_refactor_rejects_missing_acceptance_criteria() {
        let tmp = tempfile::tempdir().unwrap();
        let ctx = test_ctx(tmp.path());
        let result = tool_create_refactor(&json!({"name": "My Refactor"}), &ctx);
        assert!(result.is_err());
        assert!(
            result.unwrap_err().contains("acceptance_criteria"),
            "error should mention acceptance_criteria"
        );
    }

    #[test]
    fn tool_create_refactor_rejects_empty_acceptance_criteria() {
        let tmp = tempfile::tempdir().unwrap();
        let ctx = test_ctx(tmp.path());
        let result = tool_create_refactor(
            &json!({"name": "My Refactor", "acceptance_criteria": []}),
            &ctx,
        );
        assert!(result.is_err());
        assert!(
            result.unwrap_err().contains("acceptance_criteria"),
            "error should mention acceptance_criteria"
        );
    }

    #[test]
    fn tool_create_refactor_accepts_single_criterion() {
        let tmp = tempfile::tempdir().unwrap();
        let ctx = test_ctx(tmp.path());
        let result = tool_create_refactor(
            &json!({"name": "Single Criterion Refactor", "acceptance_criteria": ["Code is clean"]}),
            &ctx,
        );
        assert!(result.is_ok(), "expected ok: {result:?}");
        assert!(result.unwrap().contains("Created refactor:"));
    }

    #[test]
    fn tool_create_refactor_rejects_all_junk_acceptance_criteria() {
        let tmp = tempfile::tempdir().unwrap();
        let ctx = test_ctx(tmp.path());
        let result = tool_create_refactor(
            &json!({"name": "Junk Refactor", "acceptance_criteria": ["TODO", "TBD"]}),
            &ctx,
        );
        assert!(result.is_err());
        assert!(
            result.unwrap_err().contains("real entry"),
            "error should mention real entry"
        );
    }

    #[test]
    fn tool_create_refactor_accepts_mixed_junk_and_real_acceptance_criteria() {
        let tmp = tempfile::tempdir().unwrap();
        let ctx = test_ctx(tmp.path());
        let result = tool_create_refactor(
            &json!({"name": "Mixed Refactor", "acceptance_criteria": ["TODO", "Real AC"]}),
            &ctx,
        );
        assert!(result.is_ok(), "expected ok for mixed AC: {result:?}");
        assert!(result.unwrap().contains("Created refactor:"));
    }
}