// 两侧共享相同的 wire 库和预算，隔离 Dever 生成代码开销，不代替独立 JSON 引擎对比。
use dever_runtime::wire::{json::Json, serde::{Serialize, Serializer, ser::SerializeStruct}};

fn json_fault(_: impl std::fmt::Display) -> Fault {
    &FaultInfo { message: "JSON failure", source: "json-reference", line: 1, column: 1 }
}

struct Payload<'value> { values: &'value [i64] }

impl Serialize for Payload<'_> {
    fn serialize<Encoder: Serializer>(&self, encoder: Encoder) -> Result<Encoder::Ok, Encoder::Error> {
        let mut record = encoder.serialize_struct("Payload", 1)?;
        record.serialize_field("values", self.values)?;
        record.end()
    }
}

fn generated_encode(values: &[i64]) -> Result<String, Fault> {
    GENERATED_ENCODE(values).map_err(json_fault)
}

fn reference_encode(values: &[i64]) -> Result<String, Fault> {
    Json::encode(&Payload { values }).map(|value| value.as_str().to_owned()).map_err(json_fault)
}

// 独立 serde 输出不执行 Dever 的三个预算，只作为额外编码成本的下界。
fn reference_serde_encode(values: &[i64]) -> Result<String, Fault> {
    dever_runtime::wire::serde_json::to_string(&Payload { values }).map_err(json_fault)
}

// 独立 Rust 的同合同实现：两层容器，根和数组占两个值，i64 最长 20 字节。
// 值数合格时，含分隔符的最大输出不足 16 MiB，无须逐片段再次检查。
fn reference_bounded_encode(values: &[i64]) -> Result<String, Fault> {
    if values.len() > dever_runtime::wire::document::MAX_VALUES - 2 {
        return Err(json_fault("JSON value budget"));
    }
    reference_serde_encode(values)
}

fn generated_lookup(values: &[String]) -> Result<i64, Fault> {
    values.first().map_or(Ok(-1), |value| GENERATED_LOOKUP(value).map_err(json_fault))
}

fn reference_lookup(values: &[String]) -> Result<i64, Fault> {
    let Some(source) = values.first() else { return Ok(-1); };
    let json = Json::parse(source).map_err(json_fault)?;
    json.property("count").map_err(json_fault)?.map_or(Ok(-1), |value| value.as_integer().map_err(json_fault))
}

fn generated_update(values: &[String]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| GENERATED_UPDATE(value).map_err(json_fault))
}

fn reference_update(values: &[String]) -> Result<String, Fault> {
    let Some(source) = values.first() else { return Ok(String::new()); };
    let value = Json::parse(source).map_err(json_fault)?;
    let child = Json::integer(43).map_err(json_fault)?;
    value.set_property("count", &child).map(|value| value.as_str().to_owned()).map_err(json_fault)
}

fn generated_scalar_text(values: &[String]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| GENERATED_SCALAR_TEXT(value).map_err(json_fault))
}

fn reference_scalar_text(values: &[String]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| Json::string(value).map(|value| value.as_str().to_owned()).map_err(json_fault))
}

fn generated_scalar_float(values: &[f64]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| GENERATED_SCALAR_FLOAT(*value).map_err(json_fault))
}

fn reference_scalar_float(values: &[f64]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| Json::float(*value).map(|value| value.as_str().to_owned()).map_err(json_fault))
}

#[derive(Serialize)]
#[serde(crate = "dever_runtime::wire::serde")]
struct Fixed<'value> {
    text: &'value str,
    amount: i64,
    ratio: f64,
}

fn reference_fixed_value(text: &str, ratio: f64) -> Result<String, Fault> {
    if !ratio.is_finite() { return Err(json_fault("non-finite Float")); }
    Json::encode(&Fixed { text, amount: 7, ratio })
        .map(Json::into_text).map_err(json_fault)
}

fn generated_fixed(values: &[String]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| GENERATED_FIXED_RECORD(value, 4.25).map_err(json_fault))
}

fn reference_fixed(values: &[String]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| reference_fixed_value(value, 4.25))
}

fn main() {
    println!("workload,sample,implementation,nanos,checksum");
    for count in [0, 8, 256] {
        let input = [Json::parse(&serde_json::to_string(&vec!["雪山 "; count]).unwrap()).unwrap()];
        compare(&format!("json_typed_decode_{count}"), &input, 2000, generated_decode, reference_decode, |values| values.iter().map(|value| value.len() as u64).sum());
        compare(&format!("json_captured_decode_{count}"), &input, 2000, generated_captured_decode, reference_captured_decode, |value| *value as u64);
    }
    let invalid = [Json::parse("[1]").unwrap()];
    compare("json_captured_decode_invalid", &invalid, 2000, generated_captured_decode, reference_captured_decode, |value| *value as u64);
    for state in ["Ready", "Busy"] {
        let input = [Json::parse(&format!("\"{state}\"")).unwrap()];
        compare(&format!("json_enum_decode_{state}"), &input, 100_000, generated_enum_decode, reference_enum_decode, |value| u64::from(*value));
    }
    property_costs();
    raw_output_costs();
    let values = (0..256).collect::<Vec<i64>>();
    compare("json_record", &values, 2000, generated_encode, reference_encode, |value| value.len() as u64);
    for count in [16, 256, 4096] {
        let input = (0..count).collect::<Vec<i64>>();
        compare_named(&format!("json_record_serde_{count}"), &input, 2000, generated_encode, reference_serde_encode, |value| value.len() as u64, "rust_serde");
        compare_named(&format!("json_record_bounded_{count}"), &input, 2000, generated_encode, reference_bounded_encode, |value| value.len() as u64, "rust_bounded");
    }
    let maximum = vec![0; dever_runtime::wire::document::MAX_VALUES - 2];
    assert_eq!(generated_encode(&maximum).unwrap(), reference_bounded_encode(&maximum).unwrap());
    let excessive = vec![0; dever_runtime::wire::document::MAX_VALUES - 1];
    assert!(generated_encode(&excessive).is_err());
    assert!(reference_bounded_encode(&excessive).is_err());
    let source = format!(r#"{{"count":42,"ratio":1e9999,"text":"雪","values":{values:?}}}"#);
    compare("json_lookup", std::slice::from_ref(&source), 2000, generated_lookup, reference_lookup, |value| *value as u64);
    compare("json_update", &[source], 2000, generated_update, reference_update, |value| value.len() as u64);
    compare("json_scalar_text", &["雪\"\\".repeat(512)], 2000, generated_scalar_text, reference_scalar_text, |value| value.len() as u64);
    compare("json_scalar_float", &[12345.6789], 2000, generated_scalar_float, reference_scalar_float, |value| value.len() as u64);
    for bytes in [64, 4096, 65536] {
        let input = ["a".repeat(bytes)];
        assert_eq!(generated_fixed(&input).unwrap(), reference_fixed(&input).unwrap());
        compare(&format!("json_fixed_record_{bytes}"), &input, 2000, generated_fixed, reference_fixed, |value| value.len() as u64);
    }
    for ratio in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
        assert!(GENERATED_FIXED_RECORD("", ratio).is_err());
        assert!(reference_fixed_value("", ratio).is_err());
    }
    let overhead = reference_fixed_value("", 4.25).unwrap().len();
    let maximum = "a".repeat(dever_runtime::wire::document::MAX_BYTES - overhead);
    assert_eq!(GENERATED_FIXED_RECORD(&maximum, 4.25).unwrap().len(), dever_runtime::wire::document::MAX_BYTES);
    assert!(GENERATED_FIXED_RECORD(&(maximum + "a"), 4.25).is_err());
}

fn generated_decode(values: &[Json]) -> Result<Vec<String>, Fault> {
    values.first().map_or(Ok(Vec::new()), |value| GENERATED_DECODE(value).map_err(json_fault))
}

fn reference_decode(values: &[Json]) -> Result<Vec<String>, Fault> {
    // Dever 保留解码失败文本；两侧构造错误后再统一映射为基准 Fault。
    values.first().map_or(Ok(Vec::new()), |value| serde_json::from_str(value.as_str()).map_err(|error| json_fault(error.to_string())))
}

fn generated_captured_decode(values: &[Json]) -> Result<i64, Fault> {
    values.first().map_or(Ok(0), |value| GENERATED_CAPTURED_DECODE(value).map_err(json_fault))
}

fn reference_captured_decode(values: &[Json]) -> Result<i64, Fault> {
    values.first().map_or(Ok(0), |value| {
        Ok(match serde_json::from_str::<Vec<String>>(value.as_str()) {
            Ok(values) => values.len() as i64,
            Err(error) => { let _message = error.to_string(); -1 }
        })
    })
}

#[derive(dever_runtime::wire::serde::Deserialize)]
#[serde(crate = "dever_runtime::wire::serde")]
enum WireState { Ready, Busy }

fn generated_enum_decode(values: &[Json]) -> Result<bool, Fault> {
    values.first().map_or(Ok(false), |value| GENERATED_ENUM_DECODE(value).map_err(json_fault))
}

fn reference_enum_decode(values: &[Json]) -> Result<bool, Fault> {
    values.first().map_or(Ok(false), |value| {
        serde_json::from_str::<WireState>(value.as_str())
            .map(|state| matches!(state, WireState::Ready))
            .map_err(|error| json_fault(error.to_string()))
    })
}