//! Explicit reference identities and frozen rank universes shared by all daily runtimes.
use crate::{
    daily_patterns::{dataset_series, evaluate_with_context, PatternSpec, ResearchContext},
    factor_events::{field_dependencies, Expr},
    DataSet,
};
use chrono::NaiveDate;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::{BTreeMap, BTreeSet};

pub const CONTRACT: &str = "fidc_pattern_execution_context_v1";
pub const CONTEXT_FIELDS: &[&str] = &[
    "index_open",
    "index_high",
    "index_low",
    "index_close",
    "scope_rank",
    "scope_percentile",
    "scope_size",
];
const STOCK_FIELDS: &[&str] = &[
    "open",
    "high",
    "low",
    "close",
    "volume",
    "raw_open",
    "raw_high",
    "raw_low",
    "raw_close",
    "prev_close",
    "amount",
];

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExecutionContext {
    pub contract: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub benchmark: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rank_expression: Option<Expr>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub rank_universe: Vec<String>,
}

fn valid_symbol(s: &str) -> bool {
    let Some((code, market)) = s.split_once('.') else {
        return false;
    };
    code.len() == 6
        && code.bytes().all(|c| c.is_ascii_digit())
        && matches!(market, "SH" | "SZ" | "BJ" | "CSI")
}

impl ExecutionContext {
    pub fn fields(&self, expression: &Expr) -> BTreeSet<String> {
        let mut fields = field_dependencies(expression);
        if let Some(rank) = &self.rank_expression {
            fields.extend(field_dependencies(rank));
        }
        fields
    }
    pub fn validate(&self, expression: &Expr) -> Result<(), String> {
        if self.contract != CONTRACT {
            return Err("pattern_context_contract_invalid".into());
        }
        let needed = field_dependencies(expression);
        let ranked = needed.iter().any(|f| f.starts_with("scope_"));
        if ranked != self.rank_expression.is_some() || !ranked && !self.rank_universe.is_empty() {
            return Err("pattern_rank_expression_and_universe_required".into());
        }
        if ranked
            && (self.rank_universe.len() < 2
                || self.rank_universe.len() > 20_000
                || self.rank_universe.iter().any(|s| !valid_symbol(s))
                || self.rank_universe.iter().collect::<BTreeSet<_>>().len()
                    != self.rank_universe.len())
        {
            return Err("pattern_rank_universe_invalid".into());
        }
        if let Some(rank) = &self.rank_expression {
            let fields = field_dependencies(rank);
            if fields
                .iter()
                .any(|f| !STOCK_FIELDS.contains(&f.as_str()) && !f.starts_with("index_"))
            {
                return Err("pattern_rank_expression_invalid_or_recursive".into());
            }
        }
        let fields = self.fields(expression);
        if fields
            .iter()
            .any(|f| !STOCK_FIELDS.contains(&f.as_str()) && !CONTEXT_FIELDS.contains(&f.as_str()))
        {
            return Err("pattern_context_unmapped_field".into());
        }
        let index = fields.iter().any(|f| f.starts_with("index_"));
        if index != self.benchmark.is_some()
            || self
                .benchmark
                .as_ref()
                .is_some_and(|s| !valid_symbol(s) || s.ends_with(".BJ"))
        {
            return Err("pattern_reference_index_required".into());
        }
        if !index && !ranked {
            return Err("pattern_unused_context".into());
        }
        Ok(())
    }
}

pub fn build_dataset_context(
    spec: &PatternSpec,
    data: &DataSet,
    date: NaiveDate,
) -> Result<ResearchContext, String> {
    let Some(config) = &spec.execution_context else {
        return Ok(ResearchContext::default());
    };
    config.validate(
        spec.expression
            .as_ref()
            .ok_or("pattern_context_requires_expression")?,
    )?;
    let days = data.calendar().trailing_days(date, spec.history_len());
    if days.len() != spec.history_len() || days.last() != Some(&date) {
        return Err("pattern_context_calendar_incomplete".into());
    }
    let needed = config.fields(spec.expression.as_ref().unwrap());
    let mut context = ResearchContext::default();
    if let Some(symbol) = &config.benchmark {
        for name in needed.iter().filter(|f| f.starts_with("index_")) {
            let values = days
                .iter()
                .map(|d| {
                    let value = if let Some(b) = data.market(*d, symbol) {
                        match name.as_str() {
                            "index_open" => Some(b.open),
                            "index_high" => Some(b.high),
                            "index_low" => Some(b.low),
                            "index_close" => Some(b.close),
                            _ => None,
                        }
                    } else if let Some(b) = data.benchmark(*d).filter(|b| &b.benchmark == symbol) {
                        match name.as_str() {
                            "index_open" => Some(b.open),
                            "index_close" => Some(b.close),
                            _ => None,
                        }
                    } else {
                        None
                    };
                    value
                        .filter(|v| v.is_finite() && *v > 0.0)
                        .map(Some)
                        .ok_or_else(|| format!("pattern_reference_missing: {symbol} {d} {name}"))
                })
                .collect::<Result<Vec<_>, _>>()?;
            context.common.insert(name.clone(), values);
        }
    }
    if let Some(expression) = &config.rank_expression {
        let mut input = spec.clone();
        input.execution_context = None;
        input.expression = Some(expression.clone());
        let mut values = BTreeMap::new();
        for symbol in &config.rank_universe {
            let row = evaluate_with_context(
                &input,
                &days,
                &dataset_series(data, &days, symbol),
                &context.common,
                true,
            )?;
            if let Some(reason) = row.exclusion {
                return Err(format!("pattern_rank_member_incomplete: {symbol} {reason}"));
            }
            values.insert(
                symbol.clone(),
                serde_json::from_value::<Vec<Option<f64>>>(
                    row.values["expression"]["values"].clone(),
                )
                .map_err(|e| e.to_string())?,
            );
        }
        let ranks =
            crate::factor_cross_section::rank_history(&days, &config.rank_universe, &values)?;
        for symbol in &config.rank_universe {
            let decode = |value: &Value| {
                serde_json::from_value::<Vec<Option<f64>>>(value.clone()).map_err(|e| e.to_string())
            };
            context.by_symbol.insert(
                symbol.clone(),
                BTreeMap::from([
                    ("scope_rank".into(), decode(&ranks["rank"][symbol])?),
                    (
                        "scope_percentile".into(),
                        decode(&ranks["percentile"][symbol])?,
                    ),
                    (
                        "scope_size".into(),
                        vec![Some(config.rank_universe.len() as f64); days.len()],
                    ),
                ]),
            );
        }
    }
    Ok(context)
}

pub fn specs_in_value(value: &Value) -> Result<Vec<PatternSpec>, String> {
    let mut specs = Vec::new();
    match value {
        Value::String(text) => specs.extend(crate::daily_patterns::expression_specs(text)?),
        Value::Array(items) => {
            for v in items {
                specs.extend(specs_in_value(v)?);
            }
        }
        Value::Object(items) => {
            for v in items.values() {
                specs.extend(specs_in_value(v)?);
            }
        }
        _ => {}
    }
    Ok(specs)
}

pub fn required_symbols(value: &Value) -> Result<(BTreeSet<String>, BTreeSet<String>), String> {
    let (mut indices, mut stocks) = (BTreeSet::new(), BTreeSet::new());
    for spec in specs_in_value(value)? {
        if let Some(context) = spec.execution_context {
            if let Some(index) = context.benchmark {
                indices.insert(index);
            }
            stocks.extend(context.rank_universe);
        }
    }
    Ok((indices, stocks))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{BenchmarkSnapshot, DailyFactorSnapshot, DailyMarketSnapshot, Instrument};
    use serde_json::json;
    #[test]
    fn normalized_rule_does_not_turn_an_omitted_window_into_explicit_null() {
        let expression:Expr=serde_json::from_value(json!({"kind":"operator","name":"GT","args":[{"kind":"field","name":"close"},{"kind":"number","value":1}]})).unwrap();
        assert!(serde_json::to_value(expression).unwrap().get("window").is_none());
    }
    fn data(future: bool, reference: bool) -> DataSet {
        let mut days = vec![
            NaiveDate::from_ymd_opt(2026, 9, 4).unwrap(),
            NaiveDate::from_ymd_opt(2026, 9, 7).unwrap(),
            NaiveDate::from_ymd_opt(2026, 9, 8).unwrap(),
        ];
        if future {
            days.push(NaiveDate::from_ymd_opt(2026, 9, 9).unwrap());
        }
        let symbols = vec!["000001.SZ", "000002.SZ", "000003.SZ"];
        let mut instruments = symbols
            .iter()
            .map(|s| Instrument {
                symbol: s.to_string(),
                name: s.to_string(),
                board: "SZ_MAIN".into(),
                round_lot: 100,
                listed_at: None,
                delisted_at: None,
                status: "active".into(),
            })
            .collect::<Vec<_>>();
        if reference {
            instruments.push(Instrument {
                symbol: "399006.SZ".into(),
                name: "reference".into(),
                board: "INDEX".into(),
                round_lot: 1,
                listed_at: None,
                delisted_at: None,
                status: "active".into(),
            });
        }
        let mut market = vec![];
        let mut factors = vec![];
        let mut benchmark = vec![];
        for (i, d) in days.iter().enumerate() {
            for (n, s) in symbols.iter().enumerate() {
                let c = [
                    [10., 12., 11., 1000.],
                    [10., 11., 12., 1.],
                    [10., 10., 13., 1.],
                ][n][i];
                market.push(DailyMarketSnapshot {
                    date: *d,
                    symbol: s.to_string(),
                    timestamp: None,
                    day_open: c,
                    open: c,
                    high: c,
                    low: c,
                    close: c,
                    last_price: c,
                    bid1: c,
                    ask1: c,
                    prev_close: 10.,
                    volume: 100000,
                    minute_volume: 0,
                    bid1_volume: 10000,
                    ask1_volume: 10000,
                    trading_phase: None,
                    paused: false,
                    upper_limit: c * 2.,
                    lower_limit: c / 2.,
                    price_tick: 0.01,
                });
                factors.push(DailyFactorSnapshot {
                    date: *d,
                    symbol: s.to_string(),
                    market_cap_bn: 1.,
                    free_float_cap_bn: 1.,
                    pe_ttm: 10.,
                    turnover_ratio: None,
                    effective_turnover_ratio: None,
                    adjustment_factor_backward1: Some(1.),
                    extra_factors: Default::default(),
                });
            }
            if reference {
                let mut row = market.last().unwrap().clone();
                row.symbol = "399006.SZ".into();
                row.open = 30.;
                row.high = 30.;
                row.low = 30.;
                row.close = 30.;
                market.push(row);
            }
            benchmark.push(BenchmarkSnapshot {
                date: *d,
                benchmark: "000300.SH".into(),
                open: 4000.,
                close: 4000.,
                prev_close: 4000.,
                volume: 1000,
            });
        }
        DataSet::from_components(instruments, market, factors, vec![], benchmark).unwrap()
    }
    fn spec(rank: bool) -> PatternSpec {
        let expression = if rank {
            json!({"kind":"operator","name":"GT","args":[{"kind":"field","name":"scope_rank"},{"kind":"number","value":2}]})
        } else {
            json!({"kind":"operator","name":"LT","args":[{"kind":"field","name":"index_close"},{"kind":"number","value":100}]})
        };
        let context = if rank {
            json!({"contract":CONTRACT,"rank_expression":{"kind":"operator","name":"PCT_CHANGE","window":1,"args":[{"kind":"field","name":"close"}]},"rank_universe":["000001.SZ","000002.SZ","000003.SZ"]})
        } else {
            json!({"contract":CONTRACT,"benchmark":"399006.SZ"})
        };
        serde_json::from_value::<PatternSpec>(json!({"template":"expression","parameters":{"history_window":3},"expression":expression,"execution_context":context})).unwrap().validate().unwrap()
    }
    #[test]
    fn dataset_rank_is_full_scope_causal_and_equal_to_pure_cross_section() {
        let spec = spec(true);
        let date = NaiveDate::from_ymd_opt(2026, 9, 8).unwrap();
        let original = build_dataset_context(&spec, &data(false, true), date).unwrap();
        let future = build_dataset_context(&spec, &data(true, true), date).unwrap();
        assert_eq!(original.by_symbol, future.by_symbol);
        assert_eq!(original.by_symbol["000001.SZ"]["scope_rank"][2], Some(3.));
        assert_eq!(original.by_symbol["000002.SZ"]["scope_rank"][2], Some(2.));
        assert_eq!(original.by_symbol["000003.SZ"]["scope_rank"][2], Some(1.));
        assert!(
            crate::daily_patterns::evaluate_dataset(&spec, &data(false, true), date, "000001.SZ")
                .unwrap()
                .matched
        );
        let mut incomplete = data(false, true).snapshot_components();
        incomplete.market.retain(|r| r.symbol != "000003.SZ");
        let broken = DataSet::from_components(
            incomplete.instruments,
            incomplete.market,
            incomplete.factors,
            incomplete.candidates,
            incomplete.benchmarks,
        )
        .unwrap();
        assert!(build_dataset_context(&spec, &broken, date).is_err());
    }
    #[test]
    fn reference_index_never_defaults_to_performance_benchmark() {
        let spec = spec(false);
        let date = NaiveDate::from_ymd_opt(2026, 9, 8).unwrap();
        assert!(
            crate::daily_patterns::evaluate_dataset(&spec, &data(false, true), date, "000001.SZ")
                .unwrap()
                .matched
        );
        assert!(build_dataset_context(&spec, &data(false, false), date)
            .unwrap_err()
            .contains("399006.SZ"));
    }
    #[test]
    fn runtime_contract_rejects_missing_range_and_recursive_ranks() {
        let mut missing = spec(true);
        missing
            .execution_context
            .as_mut()
            .unwrap()
            .rank_universe
            .clear();
        assert!(missing.validate().is_err());
        let mut recursive = spec(true);
        recursive
            .execution_context
            .as_mut()
            .unwrap()
            .rank_expression = Some(Expr::Field {
            name: "scope_rank".into(),
        });
        assert!(recursive.validate().is_err());
    }
}