mt5-quant 1.34.3

use crate::analytics::DealAnalyzer;
use crate::models::deals::Deal;
use crate::models::metrics::Metrics;
use crate::models::Config;
use crate::storage::ReportDb;
use anyhow::Result;
use serde_json::{json, Value};
use std::collections::HashSet;
use std::fs;
use std::path::Path;

// ── Internal helpers ──────────────────────────────────────────────────────────

fn required_str<'a>(args: &'a Value, key: &str) -> Result<&'a str> {
    args.get(key)
        .and_then(|v| v.as_str())
        .ok_or_else(|| anyhow::anyhow!("{} is required", key))
}

fn ok_response(data: Value) -> Value {
    json!({
        "content": [{ "type": "text", "text": data.to_string() }],
        "isError": false
    })
}

fn err_response(msg: impl std::fmt::Display) -> Value {
    json!({
        "content": [{ "type": "text", "text": msg.to_string() }],
        "isError": true
    })
}

/// Resolve a report from args (report_id > report_dir > latest).
/// Returns (deals, metrics, report_dir).
fn resolve_report(args: &Value) -> Result<(Vec<Deal>, Metrics, String)> {
    let db = ReportDb::new(&Config::db_path());
    db.init()?;

    let entry = if let Some(id) = args.get("report_id").and_then(|v| v.as_str()) {
        db.get_by_id(id)?
            .ok_or_else(|| anyhow::anyhow!("Report '{}' not found in DB", id))?
    } else if let Some(dir) = args.get("report_dir").and_then(|v| v.as_str()) {
        db.get_by_report_dir(dir)?.ok_or_else(|| {
            anyhow::anyhow!(
                "No DB entry for report_dir '{}'. This report may predate DB storage.",
                dir
            )
        })?
    } else {
        db.get_latest()?
            .ok_or_else(|| anyhow::anyhow!("No reports in DB. Run a backtest first."))?
    };

    let deals = db.get_deals(&entry.id)?;

    let metrics_path = Path::new(&entry.report_dir).join("metrics.json");
    let metrics = if metrics_path.exists() {
        serde_json::from_str(&fs::read_to_string(&metrics_path)?)?
    } else {
        Metrics::default()
    };

    Ok((deals, metrics, entry.report_dir))
}

fn prepare_analysis(args: &Value) -> Result<(Vec<Deal>, Metrics, DealAnalyzer, String)> {
    let (deals, metrics, report_dir) = resolve_report(args)?;
    Ok((deals, metrics, DealAnalyzer::new(), report_dir))
}

// ── Composite analytics ───────────────────────────────────────────────────────

pub async fn handle_analyze_report(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, metrics, analyzer, report_dir) = prepare_analysis(args)?;

    let requested: Option<HashSet<String>> =
        args.get("analytics").and_then(|v| v.as_array()).map(|arr| {
            arr.iter()
                .filter_map(|v| v.as_str().map(|s| s.to_string()))
                .collect()
        });

    let top_losses_limit = args
        .get("top_losses_limit")
        .and_then(|v| v.as_u64())
        .unwrap_or(10) as usize;

    let all = requested.is_none();
    let req = |name: &str| {
        all || requested
            .as_ref()
            .map(|s| s.contains(name))
            .unwrap_or(false)
    };

    let mut result = json!({});

    if req("monthly_pnl") {
        result["monthly"] = json!(analyzer.monthly_pnl(&deals));
    }
    if req("drawdown_events") {
        result["dd_events"] = json!(analyzer.reconstruct_dd_events(&deals, &metrics));
    }
    if req("top_losses") {
        result["top_losses"] = json!(analyzer.top_losses(&deals, top_losses_limit));
    }
    if req("loss_sequences") {
        result["loss_sequences"] = json!(analyzer.loss_sequences(&deals));
    }
    if req("position_pairs") {
        result["position_pairs"] = json!(analyzer.position_pairs(&deals));
    }
    if req("direction_bias") {
        result["direction_bias"] = json!(analyzer.direction_bias(&deals));
    }
    if req("streak_analysis") {
        result["streak_analysis"] = json!(analyzer.streak_analysis(&deals));
    }
    if req("concurrent_peak") {
        result["concurrent_peak"] = json!(analyzer.concurrent_peak(&deals));
    }

    let analysis_path = Path::new(&report_dir).join("analysis.json");
    fs::write(&analysis_path, serde_json::to_string_pretty(&result)?)?;

    Ok(ok_response(json!({
        "success": true,
        "analysis_file": analysis_path.to_string_lossy(),
        "analytics_run": requested.map(|s| s.iter().cloned().collect::<Vec<_>>()).unwrap_or_else(|| vec!["all".to_string()]),
        "summary": result,
    })))
}

pub async fn handle_compare_baseline(_config: &Config, args: &Value) -> Result<Value> {
    let (_, _, _, report_dir) = prepare_analysis(args)?;

    let baseline_path = Path::new("config/baseline.json");
    let metrics_path = Path::new(&report_dir).join("metrics.json");

    if !baseline_path.exists() {
        return Ok(ok_response(json!("No baseline.json found in config/")));
    }

    let baseline: Value = serde_json::from_str(&fs::read_to_string(baseline_path)?)?;
    let current: Value = serde_json::from_str(&fs::read_to_string(metrics_path)?)?;

    Ok(ok_response(json!({
        "baseline": baseline,
        "current": current,
        "improvements": {
            "profit": current.get("net_profit").and_then(|v| v.as_f64()).unwrap_or(0.0)
                - baseline.get("net_profit").and_then(|v| v.as_f64()).unwrap_or(0.0),
            "drawdown": current.get("max_dd_pct").and_then(|v| v.as_f64()).unwrap_or(0.0)
                - baseline.get("max_dd_pct").and_then(|v| v.as_f64()).unwrap_or(0.0),
        }
    })))
}

// ── Granular analytics handlers ───────────────────────────────────────────────

pub async fn handle_analyze_monthly_pnl(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "monthly_pnl": analyzer.monthly_pnl(&deals) }),
    ))
}

pub async fn handle_analyze_drawdown_events(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, metrics, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "drawdown_events": analyzer.reconstruct_dd_events(&deals, &metrics) }),
    ))
}

pub async fn handle_analyze_top_losses(_config: &Config, args: &Value) -> Result<Value> {
    let limit = args.get("limit").and_then(|v| v.as_u64()).unwrap_or(10) as usize;
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "limit": limit, "top_losses": analyzer.top_losses(&deals, limit) }),
    ))
}

pub async fn handle_analyze_loss_sequences(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "loss_sequences": analyzer.loss_sequences(&deals) }),
    ))
}

pub async fn handle_analyze_position_pairs(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "position_pairs": analyzer.position_pairs(&deals) }),
    ))
}

pub async fn handle_analyze_direction_bias(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "direction_bias": analyzer.direction_bias(&deals) }),
    ))
}

pub async fn handle_analyze_streaks(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "streak_analysis": analyzer.streak_analysis(&deals) }),
    ))
}

pub async fn handle_analyze_concurrent_peak(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "concurrent_peak": analyzer.concurrent_peak(&deals) }),
    ))
}

pub async fn handle_analyze_profit_distribution(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "profit_distribution": analyzer.profit_distribution(&deals) }),
    ))
}

pub async fn handle_analyze_time_performance(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "time_performance": analyzer.time_performance(&deals) }),
    ))
}

pub async fn handle_analyze_hold_time_distribution(
    _config: &Config,
    args: &Value,
) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "hold_time_analysis": analyzer.hold_time_analysis(&deals) }),
    ))
}

pub async fn handle_analyze_layer_performance(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "layer_performance": analyzer.layer_performance(&deals) }),
    ))
}

pub async fn handle_analyze_volume_vs_profit(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "volume_analysis": analyzer.volume_analysis(&deals) }),
    ))
}

pub async fn handle_analyze_costs(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "cost_analysis": analyzer.cost_analysis(&deals) }),
    ))
}

pub async fn handle_analyze_efficiency(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, metrics, analyzer, _) = prepare_analysis(args)?;
    Ok(ok_response(
        json!({ "success": true, "efficiency_analysis": analyzer.efficiency_analysis(&deals, &metrics) }),
    ))
}

// ── Deal query handlers ───────────────────────────────────────────────────────

fn deal_to_json(d: &Deal) -> Value {
    json!({
        "time": d.time,
        "deal": d.deal,
        "symbol": d.symbol,
        "deal_type": d.deal_type,
        "volume": d.volume,
        "price": d.price,
        "profit": d.profit,
        "commission": d.commission,
        "swap": d.swap,
        "comment": d.comment,
        "magic": d.magic,
    })
}

fn is_closed_trade(d: &Deal) -> bool {
    // Accept any "out" entry. Profit may legitimately be 0.0 for journal-extracted
    // deals (where per-deal P&L is unavailable), so we don't gate on profit != 0.0.
    d.entry.to_lowercase().contains("out")
}

pub async fn handle_list_deals(_config: &Config, args: &Value) -> Result<Value> {
    let (deals, _, _, _) = prepare_analysis(args)?;

    let deal_type = args.get("deal_type").and_then(|v| v.as_str());
    let min_profit = args.get("min_profit").and_then(|v| v.as_f64());
    let max_profit = args.get("max_profit").and_then(|v| v.as_f64());
    let start_date = args.get("start_date").and_then(|v| v.as_str());
    let end_date = args.get("end_date").and_then(|v| v.as_str());
    let min_volume = args.get("min_volume").and_then(|v| v.as_f64());
    let max_volume = args.get("max_volume").and_then(|v| v.as_f64());
    let limit = args.get("limit").and_then(|v| v.as_u64()).unwrap_or(100) as usize;

    let mut filtered: Vec<&Deal> = deals
        .iter()
        .filter(|d| {
            if !is_closed_trade(d) {
                return false;
            }
            if let Some(dt) = deal_type {
                if !d.deal_type.to_lowercase().contains(dt) {
                    return false;
                }
            }
            if let Some(min) = min_profit {
                if d.profit < min {
                    return false;
                }
            }
            if let Some(max) = max_profit {
                if d.profit > max {
                    return false;
                }
            }
            if let Some(s) = start_date {
                if d.time.as_str() < s {
                    return false;
                }
            }
            if let Some(e) = end_date {
                if d.time.as_str() > e {
                    return false;
                }
            }
            if let Some(min) = min_volume {
                if d.volume < min {
                    return false;
                }
            }
            if let Some(max) = max_volume {
                if d.volume > max {
                    return false;
                }
            }
            true
        })
        .collect();

    filtered.sort_by(|a, b| b.time.cmp(&a.time));
    filtered.truncate(limit);

    Ok(ok_response(json!({
        "success": true,
        "total_deals": deals.len(),
        "filtered_count": filtered.len(),
        "deals": filtered.iter().map(|d| deal_to_json(d)).collect::<Vec<_>>(),
    })))
}

pub async fn handle_search_deals_by_comment(_config: &Config, args: &Value) -> Result<Value> {
    let query = required_str(args, "query")?;
    let limit = args.get("limit").and_then(|v| v.as_u64()).unwrap_or(50) as usize;
    let (deals, _, _, _) = prepare_analysis(args)?;
    let query_lower = query.to_lowercase();

    let mut filtered: Vec<&Deal> = deals
        .iter()
        .filter(|d| is_closed_trade(d) && d.comment.to_lowercase().contains(&query_lower))
        .collect();

    filtered.sort_by(|a, b| b.time.cmp(&a.time));
    filtered.truncate(limit);

    Ok(ok_response(json!({
        "success": true,
        "query": query,
        "matched": filtered.len(),
        "deals": filtered.iter().map(|d| deal_to_json(d)).collect::<Vec<_>>(),
    })))
}

pub async fn handle_search_deals_by_magic(_config: &Config, args: &Value) -> Result<Value> {
    let magic = required_str(args, "magic")?;
    let limit = args.get("limit").and_then(|v| v.as_u64()).unwrap_or(100) as usize;
    let (deals, _, _, _) = prepare_analysis(args)?;

    let mut filtered: Vec<&Deal> = deals
        .iter()
        .filter(|d| {
            is_closed_trade(d) && d.magic.as_ref().map(|m| m.contains(magic)).unwrap_or(false)
        })
        .collect();

    filtered.sort_by(|a, b| b.time.cmp(&a.time));
    filtered.truncate(limit);

    Ok(ok_response(json!({
        "success": true,
        "magic": magic,
        "matched": filtered.len(),
        "deals": filtered.iter().map(|d| deal_to_json(d)).collect::<Vec<_>>(),
    })))
}

#[allow(dead_code)]
fn _err_response_available() {
    let _ = err_response("");
}