//! 常量折叠：操作数均为字面量且通过语义守卫时，编译期折成单常量，
//! 发射单条 `LOAD_CONST`。折值编码逐运算符镜像运行时指令的产物编码，
//! 保证物化后与运行时执行结果逐字节一致。
//!
//! 三个域并列：数值域（`literal_constant`/`fold_binary`，两操作数形态，
//! 守卫排除字符串与 BigInt）、字符串域（`literal_units`/`fold_string_chain`/
//! `fold_template`，Addition 链与全字面量模板，单元口径与运行期
//! `push_units_to` 逐段一致）、一元/逻辑/条件域（`literal_constant_wide`/
//! `fold_unary`/`fold_logical`/`fold_conditional`，全字面量操作数折单常量）。
//!
//! 数值域语义守卫：任一操作数为 BigInt 字面量不折（BigInt 混合运行期抛
//! TypeError，BigInt 与 BigInt 有独立指令族）；`DIV`/`MOD` 除数为零不折、
//! `EXP` 指数为负不折（保持运行时指令为除零/负指数编码的唯一来源）。
//! 字符串域语义守卫：Addition 链须至少一个字符串字面量（全数字链落回
//! 数值域与 `CONCAT_N`，两域零重叠）；模板须全部 cooked 为 Some。
//! 一元/逻辑/条件域语义守卫：`+` 作用 BigInt 字面量不折（运行期抛
//! TypeError，保持运行时指令为该异常的唯一来源）。

use oxide_bytecode::module::Constant;
use oxide_parser::{BinaryOperator, Expression, LogicalOperator, UnaryOperator};
use oxide_runtime_api::{
    abstract_eq_primitives, bigint_to_string, js_number_to_string, relational_compare, strict_equality, to_boolean,
    to_int32, to_number, to_uint32,
};
use oxide_types::string_forge::{decode_key, encode_key};
use oxide_types::value::JsValue;

use crate::is_int_literal;
use crate::shared::string_pool::{pool_key_marker, pool_key_plain};

/// 字面量表达式提取常量：剥括号与一元负号后，数字（`is_int_literal` 分派
/// `Int`/`Number`）、布尔、null 三类；BigInt 字面量、字符串字面量、RegExp 与
/// 非字面量一律 `None`。
///
/// 一元负号只沿 `UnaryNegation` 链剥（含嵌套负号与括号），其余一元运算符
/// （`!`/`typeof`/`void`/`~`/`+`/`delete`）终止剥壳不折。
pub(crate) fn literal_constant(expr: &Expression) -> Option<Constant> {
    let (inner, negated) = peel_negation(expr);
    match inner {
        Expression::NumericLiteral(n) => {
            let value = if negated { -n.value } else { n.value };
            if is_int_literal(value) {
                Some(Constant::Int(value as i32))
            } else {
                Some(Constant::Number(value))
            }
        }
        Expression::BooleanLiteral(b) if !negated => Some(Constant::Boolean(b.value)),
        Expression::NullLiteral(_) if !negated => Some(Constant::Null),
        _ => None,
    }
}

/// 剥括号与一元负号链：返回内层表达式与负号层数奇偶（奇数层取负）。
fn peel_negation<'a>(expr: &'a Expression<'a>) -> (&'a Expression<'a>, bool) {
    let mut e = expr;
    let mut negated = false;
    loop {
        while let Expression::ParenthesizedExpression(p) = e {
            e = &p.expression;
        }
        if let Expression::UnaryExpression(u) = e {
            if u.operator == UnaryOperator::UnaryNegation {
                negated = !negated;
                e = &u.argument;
                continue;
            }
        }
        break;
    }
    (e, negated)
}

/// 常量转 `JsValue`（纯 NaN-box 构造，零分配）：`Int`/`Number`/`Boolean`/`Null`
/// 四臂，其余臂不可达（BigInt/String/Undefined 已被守卫排除）。
fn const_to_jsvalue(c: &Constant) -> JsValue {
    match c {
        Constant::Int(i) => JsValue::int(*i),
        Constant::Number(d) => JsValue::float(*d),
        Constant::Boolean(b) => JsValue::bool(*b),
        Constant::Null => JsValue::null(),
        _ => unreachable!("折叠操作数守卫已排除 BigInt/String/Undefined"),
    }
}

/// 常量的数值（`Int`/`Number`/`Boolean`/`Null` 均走 `ToNumber` 口径）。
fn const_to_number(c: &Constant) -> f64 {
    to_number(const_to_jsvalue(c))
}

/// 字面量表达式提取常量（宽口径）：窄口径三臂加 BigInt 字面量臂，供一元/逻辑/
/// 条件折叠识别 BigInt 字面量（`+` 的 TypeError 守卫与 `-`/`~` 的 BigInt 折值
/// 都须知道操作数是 BigInt）。
///
/// 负零字面量（奇数层负号作用于 0 字面量）保 `Number(-0.0)` 不经 Int 臂，防
/// 符号丢失（`+`/`-` 折叠产物经 `Object.is` 可观察）。BigInt 字面量解析与
/// 字面量发射器同口径，解析失败返回 `None` 不折。
pub(crate) fn literal_constant_wide(expr: &Expression) -> Option<Constant> {
    let (inner, negated) = peel_negation(expr);
    match inner {
        Expression::NumericLiteral(n) => {
            // 负零守卫：奇数层负号作用于 0 字面量保 Number(-0.0)，Int 臂会丢符号。
            if negated && n.value == 0.0 {
                return Some(Constant::Number(-0.0));
            }
            let value = if negated { -n.value } else { n.value };
            if is_int_literal(value) {
                Some(Constant::Int(value as i32))
            } else {
                Some(Constant::Number(value))
            }
        }
        Expression::BooleanLiteral(b) if !negated => Some(Constant::Boolean(b.value)),
        Expression::NullLiteral(_) if !negated => Some(Constant::Null),
        Expression::BigIntLiteral(b) => {
            let value = parse_bigint_literal(b)?;
            Some(if negated { Constant::BigInt(-value) } else { Constant::BigInt(value) })
        }
        _ => None,
    }
}

/// BigInt 字面量解析：与字面量发射器同口径（i128 快路径失败回退十进制
/// `parse_bytes`，解析失败返回 `None` 不折）。
fn parse_bigint_literal(b: &oxide_parser::BigIntLiteral) -> Option<num_bigint::BigInt> {
    if let Ok(v) = b.value.parse::<i128>() {
        Some(num_bigint::BigInt::from(v))
    } else {
        num_bigint::BigInt::parse_bytes(b.value.as_bytes(), 10)
    }
}

/// 常量的布尔值（`ToBoolean` 口径）：BigInt 臂直接判零，其余经
/// `const_to_jsvalue` 加 `to_boolean`。
fn const_to_boolean(c: &Constant) -> bool {
    if let Constant::BigInt(b) = c {
        return *b != num_bigint::BigInt::from(0);
    }
    to_boolean(const_to_jsvalue(c))
}

/// 双常量折叠分派：按操作码计算折值，守卫命中返回 `None`。
///
/// 折值编码逐运算符镜像运行时产物：
/// - `ADD`：int+int 经 `checked_add` 在 i32 内保 `Int`，溢出升 `Number`（镜像
///   `int_add`）；其余组合 f64 加（镜像 `dispatch_add` 的 `to_number` 路径）
/// - `SUB`/`MUL`/`DIV`/`MOD`：恒 `Number`（镜像 `binary_arith!` 的 `as f64`）
/// - `EXP`：恒 `Number` 的 `powf`（镜像 `exp_result`）
/// - `BIT_AND`/`BIT_OR`/`BIT_XOR`/`SHL`/`SHR`：`Int`（镜像 `to_int32`）
/// - `USHR`：结果 ≤ i32::MAX 保 `Int`，否则升 `Number`（镜像 `write_ushr_result`）
/// - `LT`/`GT`/`LTE`/`GTE`：`Boolean`（镜像 `relational_compare`，GT/LTE 交换
///   操作数，LTE/GTE 取反，`None` 归 false）
/// - `EQ`/`NEQ`：`Boolean`（镜像 `abstract_eq` 原始值核心）；
///   `STRICT_EQ`/`STRICT_NEQ`：`Boolean`（镜像 `strict_equality`）
///
/// 守卫：`DIV`/`MOD` 除数为零（`Int(0)` 与 `Number(±0.0)` 均判零）、`EXP`
/// 指数为负（`Int`/`Number` 负值均判负）返回 `None`，落回运行时路径。
pub(crate) fn fold_binary(op: BinaryOperator, l: &Constant, r: &Constant) -> Option<Constant> {
    match op {
        BinaryOperator::Addition => {
            // int+int：checked_add 在 i32 内保 Int，溢出升 f64（镜像 int_add）。
            if let (Constant::Int(a), Constant::Int(b)) = (l, r) {
                return a
                    .checked_add(*b)
                    .map(Constant::Int)
                    .or(Some(Constant::Number(*a as f64 + *b as f64)));
            }
            Some(Constant::Number(const_to_number(l) + const_to_number(r)))
        }
        BinaryOperator::Subtraction
        | BinaryOperator::Multiplication
        | BinaryOperator::Division
        | BinaryOperator::Remainder => {
            // 除零守卫：Int(0) 与 Number(±0.0) 均判零（v == 0.0 对 -0.0 亦真）。
            if matches!(op, BinaryOperator::Division | BinaryOperator::Remainder) && const_to_number(r) == 0.0 {
                return None;
            }
            // 恒 f64（镜像 binary_arith! 宏的 as f64）。
            let (ln, rn) = (const_to_number(l), const_to_number(r));
            Some(match op {
                BinaryOperator::Subtraction => Constant::Number(ln - rn),
                BinaryOperator::Multiplication => Constant::Number(ln * rn),
                BinaryOperator::Division => Constant::Number(ln / rn),
                _ => Constant::Number(ln % rn),
            })
        }
        BinaryOperator::Exponential => {
            // 负指数守卫：Int 与 Number 负值均判负。
            if const_to_number(r) < 0.0 {
                return None;
            }
            // 恒 f64 powf（镜像 exp_result）。
            Some(Constant::Number(const_to_number(l).powf(const_to_number(r))))
        }
        BinaryOperator::BitwiseAnd | BinaryOperator::BitwiseOR | BinaryOperator::BitwiseXOR => {
            let (a, b) = (to_int32(const_to_jsvalue(l)), to_int32(const_to_jsvalue(r)));
            Some(match op {
                BinaryOperator::BitwiseAnd => Constant::Int(a & b),
                BinaryOperator::BitwiseOR => Constant::Int(a | b),
                _ => Constant::Int(a ^ b),
            })
        }
        BinaryOperator::ShiftLeft | BinaryOperator::ShiftRight => {
            let a = to_int32(const_to_jsvalue(l));
            let shift = to_uint32(const_to_jsvalue(r)) & 0x1F;
            Some(match op {
                BinaryOperator::ShiftLeft => Constant::Int(a << shift),
                _ => Constant::Int(a >> shift),
            })
        }
        BinaryOperator::ShiftRightZeroFill => {
            let a = to_int32(const_to_jsvalue(l)) as u32;
            let shift = to_uint32(const_to_jsvalue(r)) & 0x1F;
            let result = a >> shift;
            // 结果 ≤ i32::MAX 保 Int，否则升 Number（镜像 write_ushr_result）。
            if result <= i32::MAX as u32 {
                Some(Constant::Int(result as i32))
            } else {
                Some(Constant::Number(result as f64))
            }
        }
        BinaryOperator::LessThan => relational(l, r, false, false),
        BinaryOperator::GreaterThan => relational(l, r, true, false),
        BinaryOperator::LessEqualThan => relational(l, r, true, true),
        BinaryOperator::GreaterEqualThan => relational(l, r, false, true),
        BinaryOperator::Equality => {
            Some(Constant::Boolean(abstract_eq_primitives(const_to_jsvalue(l), const_to_jsvalue(r))))
        }
        BinaryOperator::Inequality => {
            Some(Constant::Boolean(!abstract_eq_primitives(const_to_jsvalue(l), const_to_jsvalue(r))))
        }
        BinaryOperator::StrictEquality => {
            Some(Constant::Boolean(strict_equality(const_to_jsvalue(l), const_to_jsvalue(r))))
        }
        BinaryOperator::StrictInequality => {
            Some(Constant::Boolean(!strict_equality(const_to_jsvalue(l), const_to_jsvalue(r))))
        }
        // IN/INSTANCEOF 是对象操作，不折。
        BinaryOperator::In | BinaryOperator::Instanceof => None,
    }
}

/// 关系比较折叠：镜像运行时 dispatch 口径（GT/LTE 交换操作数，LTE/GTE 取反，
/// `None` 归 false）。
fn relational(l: &Constant, r: &Constant, swap: bool, negate: bool) -> Option<Constant> {
    let (a, b) = if swap {
        (const_to_jsvalue(r), const_to_jsvalue(l))
    } else {
        (const_to_jsvalue(l), const_to_jsvalue(r))
    };
    let cmp = relational_compare(a, b).unwrap_or(false);
    Some(Constant::Boolean(if negate { !cmp } else { cmp }))
}

/// 一元折叠分派：按操作符计算折值，守卫命中返回 `None`。
///
/// 折值编码逐运算符镜像运行时产物：
/// - `LogicalNot`：`Boolean`（镜像 `NOT` 的 `to_boolean` 取反）
/// - `UnaryNegation`：BigInt 操作数折 `BigInt`，其余恒 `Number`（镜像
///   `NEG` 的 `JsValue::float`，不保 `Int`）
/// - `UnaryPlus`：BigInt 操作数不折（运行期抛 TypeError，保持运行时指令为
///   该异常的唯一来源）；其余恒 `Number`
/// - `BitwiseNot`：BigInt 操作数折 `BigInt`，其余恒 `Int`（镜像 `to_int32`）
/// - `Typeof`：`Int`/`Number` 折 "number"、`BigInt` 折 "bigint"、`Boolean` 折
///   "boolean"、`Null` 折 "object"（结果字符串经 `pool_key_plain` 入池，逐类型
///   镜像运行时 `TYPEOF_TEXTS` 分派）
/// - `Void`：恒 `Undefined`
/// - `Delete`：引用语义非常量，不折（入口 Delete 特判先行，此臂为防御）
pub(crate) fn fold_unary(op: UnaryOperator, c: &Constant) -> Option<Constant> {
    match op {
        UnaryOperator::LogicalNot => Some(Constant::Boolean(!const_to_boolean(c))),
        UnaryOperator::UnaryNegation => match c {
            Constant::BigInt(b) => Some(Constant::BigInt(-b.clone())),
            _ => Some(Constant::Number(-const_to_number(c))),
        },
        UnaryOperator::UnaryPlus => {
            // BigInt 守卫：运行期抛 TypeError，不折。
            if matches!(c, Constant::BigInt(_)) {
                return None;
            }
            Some(Constant::Number(const_to_number(c)))
        }
        UnaryOperator::BitwiseNot => match c {
            Constant::BigInt(b) => Some(Constant::BigInt(!b.clone())),
            _ => Some(Constant::Int(!to_int32(const_to_jsvalue(c)))),
        },
        UnaryOperator::Typeof => {
            // 逐类型镜像运行时 `TYPEOF_TEXTS` 分派：BigInt 归 "bigint"
            // （独立于 Int/Double 的 "number"），Boolean 归 "boolean"，Null 归 "object"。
            let text = match c {
                Constant::Int(_) | Constant::Number(_) => "number",
                Constant::BigInt(_) => "bigint",
                Constant::Boolean(_) => "boolean",
                Constant::Null => "object",
                _ => return None,
            };
            Some(Constant::String(pool_key_plain(text)))
        }
        UnaryOperator::Void => Some(Constant::Undefined),
        UnaryOperator::Delete => None,
    }
}

/// 逻辑折叠分派：结果恒为某一操作数的原样拷贝（无类型转换，任何字面量类型
/// 均安全，含 BigInt）。
pub(crate) fn fold_logical(op: LogicalOperator, l: &Constant, r: &Constant) -> Option<Constant> {
    Some(match op {
        LogicalOperator::And => {
            if const_to_boolean(l) {
                r.clone()
            } else {
                l.clone()
            }
        }
        LogicalOperator::Or => {
            if const_to_boolean(l) {
                l.clone()
            } else {
                r.clone()
            }
        }
        LogicalOperator::Coalesce => {
            if matches!(l, Constant::Null | Constant::Undefined) {
                r.clone()
            } else {
                l.clone()
            }
        }
    })
}

/// 条件折叠分派：结果恒为 test 的布尔值选定的分支常量（原样拷贝）。
pub(crate) fn fold_conditional(test: &Constant, cons: &Constant, alt: &Constant) -> Option<Constant> {
    Some(if const_to_boolean(test) { cons.clone() } else { alt.clone() })
}

/// 可折叠字面量的单元序列（剥括号与一元负号链）：字符串字面量经
/// `pool_key_marker` 加 `decode_key` 还原单元（与字面量发射器同一池键函数）；
/// 数字字面量按 `is_int_literal` 分派 i32 itoa 或 `js_number_to_string` 后
/// UTF-16 编码；BigInt 字面量解析后 `bigint_to_string`（i128 快路径失败回退
/// 十进制 `parse_bytes`，解析失败返回 `None` 不折）；布尔与 null 为
/// "true"/"false"/"null"。
///
/// 其余形态（标识符/调用/RegExp/嵌套二元等）返回 `None`。
pub(crate) fn literal_units(expr: &Expression) -> Option<Vec<u16>> {
    let (inner, negated) = peel_negation(expr);
    match inner {
        Expression::StringLiteral(s) if !negated => Some(decode_key(&pool_key_marker(&s.value, s.lone_surrogates))),
        Expression::NumericLiteral(n) => {
            let value = if negated { -n.value } else { n.value };
            let text = if is_int_literal(value) {
                (value as i32).to_string()
            } else {
                js_number_to_string(value)
            };
            Some(text.encode_utf16().collect())
        }
        Expression::BigIntLiteral(b) => {
            let value = if let Ok(v) = b.value.parse::<i128>() {
                num_bigint::BigInt::from(v)
            } else {
                num_bigint::BigInt::parse_bytes(b.value.as_bytes(), 10)?
            };
            let value = if negated { -value } else { value };
            Some(bigint_to_string(&value).encode_utf16().collect())
        }
        Expression::BooleanLiteral(b) if !negated => {
            let text = if b.value { "true" } else { "false" };
            Some(text.encode_utf16().collect())
        }
        Expression::NullLiteral(_) if !negated => Some("null".encode_utf16().collect()),
        _ => None,
    }
}

/// 判定操作数是否为字符串字面量（剥括号）：规范判定整条 `+` 链为字符串
/// 拼接的条件。
fn is_string_literal(expr: &Expression) -> bool {
    let mut e = expr;
    while let Expression::ParenthesizedExpression(p) = e {
        e = &p.expression;
    }
    matches!(e, Expression::StringLiteral(_))
}

/// Addition 链字符串域折叠：全操作数经 `literal_units` 可定值且至少一个是
/// 字符串字面量时，拼接各段单元经 `encode_key` 回池键形态，返回
/// `Constant::String`；全数字链（无字符串字面量）返回 `None` 落回 `CONCAT_N`。
pub(crate) fn fold_string_chain(operands: &[&Expression]) -> Option<Constant> {
    // 字符串域守卫置于首行：至少一个字符串字面量，全数字链留给数值域。
    if !operands.iter().any(|op| is_string_literal(op)) {
        return None;
    }
    let mut units: Vec<u16> = Vec::new();
    for op in operands {
        units.extend(literal_units(op)?);
    }
    Some(Constant::String(encode_key(&units)))
}

/// 模板字面量折叠：全部 quasi 的 cooked 为 Some 且全部内插表达式经
/// `literal_units` 可定值时，按 quasi 与表达式交替序拼接单元经 `encode_key`
/// 回池键形态，返回 `Constant::String`；任一 cooked 为 None（非法转义，
/// 解析期 SyntaxError 的防御路径）返回 `None` 落回 `TEMPLATE_STR`。
pub(crate) fn fold_template(tl: &oxide_parser::TemplateLiteral) -> Option<Constant> {
    // cooked 守卫置于首行：任一段为 None 时整模板不折。
    if !tl.quasis.iter().all(|q| q.value.cooked.is_some()) {
        return None;
    }
    let mut units: Vec<u16> = Vec::new();
    for (i, q) in tl.quasis.iter().enumerate() {
        let cooked = q.value.cooked.as_ref().expect("守卫已确认全部 cooked 为 Some");
        units.extend(decode_key(&pool_key_marker(cooked, q.lone_surrogates)));
        if let Some(expr) = tl.expressions.get(i) {
            units.extend(literal_units(expr)?);
        }
    }
    Some(Constant::String(encode_key(&units)))
}