// 阶段诊断复用正式入口；shared 标签只测运行库，不是独立 Rust 引擎参照。
// map 场景名保留历史编号，Rust 参照仍构造 Map；当前 Dever 直接拥有节点 List。
struct PreparedDocument {
    generated: DOCUMENT_TYPE,
    reference: (i64, indexmap::IndexMap<i64, ReferenceNode>),
    raw: document::Document,
}

fn reference_nodes(parsed: document::Document) -> (i64, indexmap::IndexMap<i64, ReferenceNode>) {
    let mut nodes = indexmap::IndexMap::with_capacity(parsed.nodes.len());
    for (index, value) in parsed.nodes.into_iter().enumerate() {
        let value = match value {
            document::Value::Null => ReferenceNode::Null,
            document::Value::Boolean(value) => ReferenceNode::Boolean(value),
            document::Value::Number(value) => ReferenceNode::Number(value),
            document::Value::String(value) => ReferenceNode::String(value),
            document::Value::Array(values) => ReferenceNode::Array(values),
            document::Value::Object(values) => ReferenceNode::Object(values.map_or_else(|| Map::with_capacity(0), |values| *values)),
        };
        nodes.insert(index as i64, value);
    }
    (parsed.root as i64, nodes)
}

fn phase_raw_parse(values: &[String]) -> Result<usize, Fault> {
    values.first().map_or(Ok(0), |source| {
        document::parse_with_depth(source, document::DOCUMENT_MAX_DEPTH)
            .map(|parsed| black_box(parsed).nodes.len()).map_err(document_fault)
    })
}

fn phase_generated_parse(values: &[String]) -> Result<usize, Fault> {
    values.first().map_or(Ok(0), |source| {
        GENERATED_PARSE(source).map(|parsed| black_box(parsed).field1.len()).map_err(document_fault)
    })
}

fn phase_reference_parse(values: &[String]) -> Result<usize, Fault> {
    values.first().map_or(Ok(0), |source| {
        document::parse_with_depth(source, document::DOCUMENT_MAX_DEPTH)
            .map(|parsed| black_box(reference_nodes(parsed)).1.len()).map_err(document_fault)
    })
}

fn phase_generated_write(values: &[PreparedDocument]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| GENERATED_WRITE(&value.generated).map_err(document_fault))
}

fn phase_reference_write(values: &[PreparedDocument]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| reference_map_write(value.reference.0, &value.reference.1))
}

fn phase_raw_write(values: &[PreparedDocument]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| {
        document::stringify_with_depth(&value.raw, document::DOCUMENT_MAX_DEPTH).map_err(document_fault)
    })
}

#[derive(Debug)]
enum PhaseWriteFailure {
    Fault(Fault),
    Write(i64, String, Fault),
}

impl std::fmt::Display for PhaseWriteFailure {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Fault(fault) | Self::Write(_, _, fault) => fault.fmt(formatter),
        }
    }
}

fn phase_contract_write(values: &[PreparedDocument]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| reference_contract_write(&value.generated).map_err(document_fault))
}

fn phase_adapter_write(values: &[PreparedDocument]) -> Result<String, Fault> {
    values.first().map_or(Ok(String::new()), |value| runtime_contract_write(&value.generated).map_err(document_fault))
}

// 同一份节点直接调用当前运行库，只衡量生成适配，不作为独立 JSON 引擎参照。
fn runtime_contract_write(value: &DOCUMENT_TYPE) -> Result<String, PhaseWriteFailure> {
    let origin = &FaultInfo { message: "StringifyResult.Failed", source: "document-reference", line: 1, column: 1 };
    let root = usize::try_from(value.field0).map_err(|_| {
        PhaseWriteFailure::Write(value.field0, "negative JSON root".into(), origin)
    })?;
    document::stringify_slice(root, &value.field1, document::DOCUMENT_MAX_DEPTH)
        .map_err(|error| PhaseWriteFailure::Write(error.node as i64, error.message, origin))
}

// 同一实参及错误布局，只隔离生成层；解析和输出引擎仍共享。
fn reference_contract_write(value: &DOCUMENT_TYPE) -> Result<String, PhaseWriteFailure> {
    let origin = &FaultInfo { message: "StringifyResult.Failed", source: "document-reference", line: 1, column: 1 };
    let fail = |node, message: &str| PhaseWriteFailure::Write(node, message.into(), origin);
    let root = usize::try_from(value.field0).map_err(|_| fail(value.field0, "negative JSON root"))?;
    reference_writer::stringify_nodes(root, value.field1.len(), |index| {
        match &value.field1[index] {
            document::Value::Null => reference_writer::Node::Null,
            document::Value::Boolean(value) => reference_writer::Node::Boolean(*value),
            document::Value::Number(value) => reference_writer::Node::Number(value.as_str()),
            document::Value::String(value) => reference_writer::Node::String(value.as_str()),
            document::Value::Array(values) => reference_writer::Node::Array(values.iter().copied()),
            document::Value::Object(values) => reference_writer::Node::Object(values.iter().flat_map(|values| values.iter()).map(|(name, id)| (name.as_str(), *id))),
        }
    }, document::DOCUMENT_MAX_DEPTH).map_err(|error| PhaseWriteFailure::Write(error.node as i64, error.message, origin))
}

fn main() {
    println!("case,sample,implementation,elapsed_ns,checksum");
    let numbers = format!("[{}]", vec!["1234567890123456789012345678901234e-12"; 256].join(","));
    let mut nested = "1e9999".to_owned();
    for _ in 0..48 { nested = format!("{{\"value\":{nested}}}"); }
    let text = dever_runtime::wire::json::Json::encode(&vec!["雪\\\"\n".repeat(256); 32]).unwrap().as_str().to_owned();
    let ascii = dever_runtime::wire::serde_json::to_string(&vec!["abcdef".repeat(256); 32]).unwrap();
    let unicode = dever_runtime::wire::serde_json::to_string(&vec!["雪🙂".repeat(256); 32]).unwrap();
    for (name, source) in [("numbers", numbers), ("nested", nested), ("text", text), ("ascii", ascii), ("unicode", unicode)] {
        let prepared = PreparedDocument {
            generated: GENERATED_PARSE(&source).unwrap(),
            reference: reference_nodes(document::parse_with_depth(&source, document::DOCUMENT_MAX_DEPTH).unwrap()),
            raw: document::parse_with_depth(&source, document::DOCUMENT_MAX_DEPTH).unwrap(),
        };
        let inputs = std::slice::from_ref(&source);
        compare_named(&format!("{name}_parse_shared"), inputs, 100, phase_raw_parse, phase_raw_parse, |count| *count as u64, "shared");
        compare(&format!("{name}_parse_map"), inputs, 100, phase_generated_parse, phase_reference_parse, |count| *count as u64);
        let values = &[prepared];
        compare_named(&format!("{name}_write_shared"), values, 100, phase_raw_write, phase_raw_write, |value| value.bytes().map(u64::from).sum(), "shared");
        compare(&format!("{name}_write_map"), values, 100, phase_generated_write, phase_reference_write, |value| value.bytes().map(u64::from).sum());
        compare(&format!("{name}_write_map_contract"), values, 100, phase_generated_write, phase_contract_write, |value| value.bytes().map(u64::from).sum());
        compare_named(&format!("{name}_write_adapter"), values, 100, phase_generated_write, phase_adapter_write, |value| value.bytes().map(u64::from).sum(), "shared_engine");
    }
}