//! Dated non-tradability and valuation are separate from execution quotations.
use super::*;

pub(super) fn validate(
    signal_date: NaiveDate,
    constraints: &StockPoolDecisionConstraints,
    current: &BTreeMap<String, (Decimal, Decimal, Decimal)>,
) -> Result<(), String> {
    for (symbol, fact) in &constraints.frozen_positions {
        if constraints.execution_date != Some(fact.trade_date)
            || fact.trade_date < signal_date
            || fact.reason != "paused"
            || fact.valuation_price <= Decimal::ZERO
            || current.get(symbol).is_none_or(|row| row.0 <= Decimal::ZERO)
        {
            return Err(format!("stock_pool_frozen_position_invalid:{symbol}"));
        }
    }
    if constraints
        .prior_target_weights
        .iter()
        .any(|(symbol, weight)| {
            normalize_stock_symbol(symbol).as_ref() != Some(symbol)
                || !(0..=10_000).contains(weight)
        })
    {
        return Err("stock_pool_prior_target_weights_invalid".into());
    }
    if constraints.prior_target_weight_ratios.iter().any(|(symbol, ratio)| {
        normalize_stock_symbol(symbol).as_ref() != Some(symbol) || *ratio < Decimal::ZERO || *ratio > Decimal::ONE
    }) { return Err("stock_pool_prior_target_weight_ratios_invalid".into()); }
    Ok(())
}

/// Never size cash with the rounded display bps. Paused holdings keep the
/// actually recorded prior ratio. Legacy bps are preserved, not guessed as 1/N.
pub(super) fn sizing_ratios(
    original: &[String], active: &[String], explicit: &BTreeMap<String, i32>,
    constraints: &StockPoolDecisionConstraints, reserved_slots: usize,
    display: &BTreeMap<String, i32>,
) -> Result<BTreeMap<String, Decimal>, String> {
    if !explicit.is_empty() {
        return Ok(display.iter().map(|(symbol, weight)| (symbol.clone(), Decimal::from(*weight) / Decimal::from(10_000))).collect());
    }
    if constraints.frozen_positions.is_empty() {
        let count = active.len() + reserved_slots;
        let share = if count == 0 { Decimal::ZERO } else { Decimal::ONE / Decimal::from(count as u64) };
        return Ok(active.iter().map(|symbol| (symbol.clone(), share)).collect());
    }
    let count = original.len() + reserved_slots;
    let base = if count == 0 { Decimal::ZERO } else { Decimal::ONE / Decimal::from(count as u64) };
    let mut result = BTreeMap::new();
    for symbol in constraints.frozen_positions.keys() {
        let ratio = constraints.prior_target_weight_ratios.get(symbol).copied()
            .or_else(|| constraints.prior_target_weights.get(symbol).map(|bps| Decimal::from(*bps) / Decimal::from(10_000)))
            .unwrap_or(base);
        result.insert(symbol.clone(), ratio);
    }
    let frozen_total = result.values().copied().sum::<Decimal>();
    // Only allow last-digit residue from Decimal division, never a meaningful
    // over-allocation. All actual cash/fee checks remain downstream.
    if frozen_total > Decimal::ONE + Decimal::new(1, 24) {
        return Err("stock_pool_frozen_position_ratios_exceed_budget".into());
    }
    let free_original = original.iter().filter(|symbol| !result.contains_key(*symbol)).collect::<BTreeSet<_>>();
    let free_total = (base * Decimal::from(free_original.len() as u64)).min((Decimal::ONE - frozen_total).max(Decimal::ZERO));
    let share = if free_original.is_empty() { Decimal::ZERO } else { free_total / Decimal::from(free_original.len() as u64) };
    let free = active.iter().filter(|symbol| !constraints.frozen_positions.contains_key(*symbol)).collect::<Vec<_>>();
    let promoted = free.iter().filter(|symbol| !free_original.contains(**symbol)).copied().collect::<Vec<_>>();
    for symbol in &free { result.insert((*symbol).clone(), if free_original.contains(*symbol) { share } else { Decimal::ZERO }); }
    let assigned = free.iter().map(|symbol| result[*symbol]).sum::<Decimal>();
    let missing = (free_total - assigned).max(Decimal::ZERO);
    let recipients = if promoted.is_empty() { &free } else { &promoted };
    if !recipients.is_empty() {
        let addition = missing / Decimal::from(recipients.len() as u64);
        for symbol in recipients { *result.entry((*symbol).clone()).or_default() += addition; }
    }
    Ok(result)
}

pub(super) fn valuation(
    symbol: &str,
    quotes: &HashMap<String, &MarketSnapshot>,
    frozen: &BTreeMap<String, FrozenStockPoolPosition>,
) -> Result<Decimal, String> {
    frozen
        .get(symbol)
        .map(|fact| fact.valuation_price)
        .or_else(|| quotes.get(symbol).map(|quote| quote.last_price))
        .filter(|price| *price > Decimal::ZERO)
        .ok_or_else(|| format!("{symbol} confirmed holding valuation missing"))
}

#[cfg(test)]
mod ratio_tests {
    use super::*;
    fn configuration() -> (Vec<String>, StockPoolDecisionConstraints, BTreeMap<String,i32>) {
        let symbols: Vec<String> = vec!["000001.SZ".into(),"000002.SZ".into(),"000003.SZ".into()];
        let paused = FrozenStockPoolPosition { trade_date: NaiveDate::from_ymd_opt(2026,9,3).unwrap(), reason:"paused".into(), valuation_price:Decimal::from(10) };
        let constraints = StockPoolDecisionConstraints { frozen_positions:BTreeMap::from([(symbols[0].clone(),paused)]),
            prior_target_weights:BTreeMap::from([(symbols[0].clone(),3334)]), ..Default::default() };
        let display = BTreeMap::from([(symbols[0].clone(),3334),(symbols[1].clone(),3333),(symbols[2].clone(),3333)]);
        (symbols,constraints,display)
    }
    #[test]
    fn precise_paused_budget_survives_replacement_and_zero_targets() {
        let (symbols,mut constraints,display)=configuration();
        let third=Decimal::ONE/Decimal::from(3);
        constraints.prior_target_weight_ratios.insert(symbols[0].clone(),third);
        let mut active=symbols.clone();active[2]="000004.SZ".into();
        let ratios=sizing_ratios(&symbols,&active,&BTreeMap::new(),&constraints,0,&display).unwrap();
        assert_eq!(ratios[&symbols[0]],third);
        assert_eq!(ratios[&symbols[1]],third);
        assert!((ratios["000004.SZ"]-third).abs()<Decimal::new(1,24));
        assert!(!ratios.contains_key(&symbols[2]));
        assert!((ratios.values().copied().sum::<Decimal>()-Decimal::ONE).abs()<Decimal::new(1,24));
    }
    #[test]
    fn legacy_paused_and_explicit_partial_budgets_are_not_reinterpreted() {
        let (symbols,constraints,display)=configuration();
        let ratios=sizing_ratios(&symbols,&symbols,&BTreeMap::new(),&constraints,0,&display).unwrap();
        assert_eq!(ratios[&symbols[0]],Decimal::new(3334,4));
        assert!((ratios[&symbols[1]]-Decimal::new(3333,4)).abs()<Decimal::new(1,24));
        let partial=BTreeMap::from([(symbols[0].clone(),2000),(symbols[1].clone(),0)]);
        assert_eq!(sizing_ratios(&symbols,&symbols,&partial,&constraints,0,&partial).unwrap(),
            BTreeMap::from([(symbols[0].clone(),Decimal::new(2,1)),(symbols[1].clone(),Decimal::ZERO)]));
    }
    #[test]
    fn precision_is_checked_before_frozen_budget_is_allocated() {
        let (symbols,mut constraints,display)=configuration();
        constraints.prior_target_weight_ratios.insert(symbols[0].clone(),Decimal::new(1001,3));
        assert!(sizing_ratios(&symbols,&symbols,&BTreeMap::new(),&constraints,0,&display).is_err());
    }
}

pub(super) fn weights(
    original: &[String],
    active: &[String],
    members: &[StockPoolMemberSpec],
    explicit: &BTreeMap<String, i32>,
    constraints: &StockPoolDecisionConstraints,
    reserved_slots: usize,
    target_count: usize,
) -> Result<BTreeMap<String, i32>, String> {
    let count = original.len() + reserved_slots;
    let order = members
        .iter()
        .map(|member| (&member.symbol, member.requested_order))
        .collect::<BTreeMap<_, _>>();
    let mut original_budget_symbols = original.to_vec();
    for symbol in constraints.frozen_positions.keys() {
        if order.contains_key(symbol) && !original_budget_symbols.contains(symbol) {
            original_budget_symbols.push(symbol.clone());
        }
    }
    if original_budget_symbols.len() != original.len() {
        original_budget_symbols
            .sort_by_key(|symbol| order.get(symbol).copied().unwrap_or(i32::MAX));
    }
    let initial = original_budget_symbols
        .iter()
        .enumerate()
        .map(|(index, symbol)| {
            let weight = if explicit.is_empty() {
                if count == 0 {
                    0
                } else {
                    10_000 / count as i32 + i32::from(index < 10_000 % count)
                }
            } else {
                *explicit.get(symbol).unwrap_or(&0)
            };
            (symbol.clone(), weight)
        })
        .collect::<Vec<_>>();
    let mut frozen = BTreeMap::new();
    for symbol in constraints.frozen_positions.keys() {
        let weight = explicit
            .get(symbol)
            .copied()
            .or_else(|| constraints.prior_target_weights.get(symbol).copied())
            .or_else(|| {
                initial
                    .iter()
                    .find(|(key, _)| key == symbol)
                    .map(|(_, weight)| *weight)
            })
            .ok_or_else(|| format!("stock_pool_frozen_position_target_weight_missing:{symbol}"))?;
        frozen.insert(symbol.clone(), weight);
    }
    let frozen_total = frozen.values().copied().sum::<i32>();
    if frozen_total > 10_000 {
        return Err("stock_pool_frozen_position_weights_exceed_budget".into());
    }
    let mut free = initial
        .into_iter()
        .filter(|(symbol, _)| !frozen.contains_key(symbol))
        .map(|(symbol, weight)| (symbol, weight as u32))
        .collect::<Vec<_>>();
    let total = free.iter().map(|(_, weight)| *weight).sum::<u32>();
    let available = (10_000 - frozen_total) as u32;
    // A paused holding removed from today's candidates still owns its prior
    // budget. Scale only the new tradable allocation, never the frozen leg.
    if total > available {
        let mut remainder = available;
        for (_, weight) in &mut free {
            *weight = (u64::from(*weight) * u64::from(available) / u64::from(total)) as u32;
            remainder -= *weight;
        }
        for (_, weight) in free.iter_mut().take(remainder as usize) {
            *weight += 1;
        }
    }
    let excluded = free
        .iter()
        .filter(|(symbol, _)| !active.contains(symbol))
        .map(|(symbol, _)| symbol.clone())
        .collect();
    let candidates = active
        .iter()
        .filter(|symbol| !frozen.contains_key(*symbol))
        .cloned()
        .collect::<Vec<_>>();
    let allocated = crate::platform_expr_strategy::replenish_target_weight_bps(
        &free,
        &candidates,
        &excluded,
        target_count.saturating_sub(
            frozen
                .keys()
                .filter(|symbol| original.contains(symbol))
                .count(),
        ),
    );
    frozen.extend(
        allocated
            .into_iter()
            .map(|(symbol, weight)| (symbol, weight as i32)),
    );
    Ok(frozen)
}