use std::cell::RefCell;
use std::collections::{BTreeMap, BTreeSet};
use std::rc::Rc;

use chrono::NaiveDate;
use fidc_core::{
    BacktestConfig, BacktestEngine, BenchmarkSnapshot, BrokerSimulator, CandidateEligibility,
    ChinaAShareCostModel, ChinaEquityRuleHooks, DailyFactorSnapshot, DailyMarketSnapshot, DataSet,
    Instrument, PriceField, Strategy, StrategyContext, StrategyDecision,
};

fn d(year: i32, month: u32, day: u32) -> NaiveDate {
    NaiveDate::from_ymd_opt(year, month, day).expect("valid date")
}

struct HookProbeStrategy {
    log: Rc<RefCell<Vec<String>>>,
}

impl Strategy for HookProbeStrategy {
    fn name(&self) -> &str {
        "hook-probe"
    }

    fn before_trading(
        &mut self,
        ctx: &StrategyContext<'_>,
    ) -> Result<(), fidc_core::BacktestError> {
        self.log
            .borrow_mut()
            .push(format!("before:{}", ctx.execution_date));
        Ok(())
    }

    fn open_auction(
        &mut self,
        ctx: &StrategyContext<'_>,
    ) -> Result<StrategyDecision, fidc_core::BacktestError> {
        self.log
            .borrow_mut()
            .push(format!("auction:{}", ctx.execution_date));
        Ok(StrategyDecision::default())
    }

    fn on_day(
        &mut self,
        ctx: &StrategyContext<'_>,
    ) -> Result<StrategyDecision, fidc_core::BacktestError> {
        self.log
            .borrow_mut()
            .push(format!("on_day:{}", ctx.execution_date));
        Ok(StrategyDecision {
            rebalance: false,
            target_weights: BTreeMap::new(),
            exit_symbols: BTreeSet::new(),
            order_intents: Vec::new(),
            notes: Vec::new(),
            diagnostics: Vec::new(),
        })
    }

    fn after_trading(&mut self, ctx: &StrategyContext<'_>) -> Result<(), fidc_core::BacktestError> {
        self.log
            .borrow_mut()
            .push(format!("after:{}", ctx.execution_date));
        Ok(())
    }

    fn on_settlement(&mut self, ctx: &StrategyContext<'_>) -> Result<(), fidc_core::BacktestError> {
        self.log
            .borrow_mut()
            .push(format!("settlement:{}", ctx.execution_date));
        Ok(())
    }
}

struct AuctionOrderStrategy {
    saw_quantity_in_on_day: Rc<RefCell<Option<u32>>>,
}

impl Strategy for AuctionOrderStrategy {
    fn name(&self) -> &str {
        "auction-order"
    }

    fn open_auction(
        &mut self,
        _ctx: &StrategyContext<'_>,
    ) -> Result<StrategyDecision, fidc_core::BacktestError> {
        Ok(StrategyDecision {
            rebalance: false,
            target_weights: BTreeMap::new(),
            exit_symbols: BTreeSet::new(),
            order_intents: vec![fidc_core::OrderIntent::Value {
                symbol: "000001.SZ".to_string(),
                value: 1_000.0,
                reason: "auction_buy".to_string(),
            }],
            notes: Vec::new(),
            diagnostics: Vec::new(),
        })
    }

    fn on_day(
        &mut self,
        ctx: &StrategyContext<'_>,
    ) -> Result<StrategyDecision, fidc_core::BacktestError> {
        let quantity = ctx
            .portfolio
            .position("000001.SZ")
            .map(|position| position.quantity)
            .unwrap_or(0);
        *self.saw_quantity_in_on_day.borrow_mut() = Some(quantity);
        Ok(StrategyDecision::default())
    }
}

#[test]
fn engine_runs_strategy_hooks_in_daily_order() {
    let date1 = d(2025, 1, 2);
    let date2 = d(2025, 1, 3);
    let data = DataSet::from_components(
        vec![Instrument {
            symbol: "000001.SZ".to_string(),
            name: "Anchor".to_string(),
            board: "SZ".to_string(),
            round_lot: 100,
            listed_at: Some(d(2020, 1, 1)),
            delisted_at: None,
            status: "active".to_string(),
        }],
        vec![
            DailyMarketSnapshot {
                date: date1,
                symbol: "000001.SZ".to_string(),
                timestamp: Some("2025-01-02 10:18:00".to_string()),
                day_open: 10.0,
                open: 10.0,
                high: 10.0,
                low: 10.0,
                close: 10.0,
                last_price: 10.0,
                bid1: 10.0,
                ask1: 10.0,
                prev_close: 10.0,
                volume: 100_000,
                tick_volume: 100_000,
                bid1_volume: 100_000,
                ask1_volume: 100_000,
                trading_phase: Some("continuous".to_string()),
                paused: false,
                upper_limit: 11.0,
                lower_limit: 9.0,
                price_tick: 0.01,
            },
            DailyMarketSnapshot {
                date: date2,
                symbol: "000001.SZ".to_string(),
                timestamp: Some("2025-01-03 10:18:00".to_string()),
                day_open: 10.1,
                open: 10.1,
                high: 10.1,
                low: 10.1,
                close: 10.1,
                last_price: 10.1,
                bid1: 10.1,
                ask1: 10.1,
                prev_close: 10.0,
                volume: 110_000,
                tick_volume: 110_000,
                bid1_volume: 110_000,
                ask1_volume: 110_000,
                trading_phase: Some("continuous".to_string()),
                paused: false,
                upper_limit: 11.0,
                lower_limit: 9.0,
                price_tick: 0.01,
            },
        ],
        vec![
            DailyFactorSnapshot {
                date: date1,
                symbol: "000001.SZ".to_string(),
                market_cap_bn: 20.0,
                free_float_cap_bn: 18.0,
                pe_ttm: 10.0,
                turnover_ratio: Some(1.0),
                effective_turnover_ratio: Some(1.0),
                extra_factors: BTreeMap::new(),
            },
            DailyFactorSnapshot {
                date: date2,
                symbol: "000001.SZ".to_string(),
                market_cap_bn: 21.0,
                free_float_cap_bn: 19.0,
                pe_ttm: 10.0,
                turnover_ratio: Some(1.0),
                effective_turnover_ratio: Some(1.0),
                extra_factors: BTreeMap::new(),
            },
        ],
        vec![
            CandidateEligibility {
                date: date1,
                symbol: "000001.SZ".to_string(),
                is_st: false,
                is_new_listing: false,
                is_paused: false,
                allow_buy: true,
                allow_sell: true,
                is_kcb: false,
                is_one_yuan: false,
            },
            CandidateEligibility {
                date: date2,
                symbol: "000001.SZ".to_string(),
                is_st: false,
                is_new_listing: false,
                is_paused: false,
                allow_buy: true,
                allow_sell: true,
                is_kcb: false,
                is_one_yuan: false,
            },
        ],
        vec![
            BenchmarkSnapshot {
                date: date1,
                benchmark: "000300.SH".to_string(),
                open: 100.0,
                close: 100.0,
                prev_close: 99.0,
                volume: 1_000_000,
            },
            BenchmarkSnapshot {
                date: date2,
                benchmark: "000300.SH".to_string(),
                open: 101.0,
                close: 101.0,
                prev_close: 100.0,
                volume: 1_100_000,
            },
        ],
    )
    .expect("dataset");

    let log = Rc::new(RefCell::new(Vec::new()));
    let strategy = HookProbeStrategy { log: log.clone() };
    let broker = BrokerSimulator::new_with_execution_price(
        ChinaAShareCostModel::default(),
        ChinaEquityRuleHooks::default(),
        PriceField::Open,
    );
    let mut engine = BacktestEngine::new(
        data,
        strategy,
        broker,
        BacktestConfig {
            initial_cash: 100_000.0,
            benchmark_code: "000300.SH".to_string(),
            start_date: Some(date1),
            end_date: Some(date2),
            decision_lag_trading_days: 0,
            execution_price_field: PriceField::Open,
        },
    );

    engine.run().expect("backtest succeeds");

    assert_eq!(
        log.borrow().as_slice(),
        [
            "before:2025-01-02",
            "auction:2025-01-02",
            "on_day:2025-01-02",
            "after:2025-01-02",
            "settlement:2025-01-02",
            "before:2025-01-03",
            "auction:2025-01-03",
            "on_day:2025-01-03",
            "after:2025-01-03",
            "settlement:2025-01-03",
        ]
    );
}

#[test]
fn engine_executes_open_auction_decisions_before_on_day() {
    let date = d(2025, 1, 2);
    let data = DataSet::from_components(
        vec![Instrument {
            symbol: "000001.SZ".to_string(),
            name: "Anchor".to_string(),
            board: "SZ".to_string(),
            round_lot: 100,
            listed_at: Some(d(2020, 1, 1)),
            delisted_at: None,
            status: "active".to_string(),
        }],
        vec![DailyMarketSnapshot {
            date,
            symbol: "000001.SZ".to_string(),
            timestamp: Some("2025-01-02 09:25:00".to_string()),
            day_open: 10.0,
            open: 10.0,
            high: 10.0,
            low: 10.0,
            close: 10.0,
            last_price: 10.0,
            bid1: 10.0,
            ask1: 10.0,
            prev_close: 10.0,
            volume: 100_000,
            tick_volume: 100_000,
            bid1_volume: 100_000,
            ask1_volume: 100_000,
            trading_phase: Some("open_auction".to_string()),
            paused: false,
            upper_limit: 11.0,
            lower_limit: 9.0,
            price_tick: 0.01,
        }],
        vec![DailyFactorSnapshot {
            date,
            symbol: "000001.SZ".to_string(),
            market_cap_bn: 20.0,
            free_float_cap_bn: 18.0,
            pe_ttm: 10.0,
            turnover_ratio: Some(1.0),
            effective_turnover_ratio: Some(1.0),
            extra_factors: BTreeMap::new(),
        }],
        vec![CandidateEligibility {
            date,
            symbol: "000001.SZ".to_string(),
            is_st: false,
            is_new_listing: false,
            is_paused: false,
            allow_buy: true,
            allow_sell: true,
            is_kcb: false,
            is_one_yuan: false,
        }],
        vec![BenchmarkSnapshot {
            date,
            benchmark: "000300.SH".to_string(),
            open: 100.0,
            close: 100.0,
            prev_close: 99.0,
            volume: 1_000_000,
        }],
    )
    .expect("dataset");

    let observed_quantity = Rc::new(RefCell::new(None));
    let strategy = AuctionOrderStrategy {
        saw_quantity_in_on_day: observed_quantity.clone(),
    };
    let broker = BrokerSimulator::new_with_execution_price(
        ChinaAShareCostModel::default(),
        ChinaEquityRuleHooks::default(),
        PriceField::DayOpen,
    );
    let mut engine = BacktestEngine::new(
        data,
        strategy,
        broker,
        BacktestConfig {
            initial_cash: 10_000.0,
            benchmark_code: "000300.SH".to_string(),
            start_date: Some(date),
            end_date: Some(date),
            decision_lag_trading_days: 0,
            execution_price_field: PriceField::DayOpen,
        },
    );

    let result = engine.run().expect("backtest run");
    assert_eq!(*observed_quantity.borrow(), Some(100));
    assert_eq!(result.fills.len(), 1);
    assert_eq!(result.fills[0].reason, "auction_buy");
    assert_eq!(result.fills[0].quantity, 100);
}