use crate::codegen::{self, CodegenError, ExecutionResult, MachineCode};
use crate::emit::{self, EmitError};
use crate::l0_ir::L0Program;
use crate::l1_ir::L1Program;
use crate::parser::{self, ParseError};
use crate::translate_validate::{self, VerificationReport};
use crate::verify_l0;
use crate::verify_l1::{self, VerifyError};
use std::fmt;

/// Errors from any stage of the pipeline.
#[derive(Debug)]
pub enum PipelineError {
    Parse(ParseError),
    VerifyL1(VerifyError),
    Emit(EmitError),
    VerifyL0(Vec<verify_l0::L0VerifyError>),
    Codegen(CodegenError),
    TranslationValidation(String),
}

impl fmt::Display for PipelineError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            PipelineError::Parse(e) => write!(f, "parse: {}", e),
            PipelineError::VerifyL1(e) => write!(f, "L1 verify: {}", e),
            PipelineError::Emit(e) => write!(f, "emit: {}", e),
            PipelineError::VerifyL0(errs) => {
                write!(f, "L0 verify:")?;
                for e in errs {
                    write!(f, " {}", e)?;
                }
                Ok(())
            }
            PipelineError::Codegen(e) => write!(f, "codegen: {}", e),
            PipelineError::TranslationValidation(msg) => write!(f, "translation validation: {}", msg),
        }
    }
}

impl std::error::Error for PipelineError {}

/// All intermediate representations captured during pipeline execution.
pub struct PipelineIR {
    pub l1: L1Program,
    pub l0: L0Program,
    pub machine_code: MachineCode,
}

/// Run the full pipeline: DSL text -> parse -> L1 IR -> verify -> emit L0 IR
/// -> verify -> codegen -> execute.
///
/// Returns both the execution result and captured intermediate representations.
pub fn run(source: &str) -> Result<(ExecutionResult, PipelineIR), PipelineError> {
    // Parse
    let l1 = parser::parse(source).map_err(PipelineError::Parse)?;

    // Verify L1
    verify_l1::verify(&l1).map_err(PipelineError::VerifyL1)?;

    // Emit L0 IR
    let l0 = emit::emit(&l1).map_err(PipelineError::Emit)?;

    // Verify L0
    verify_l0::verify(&l0).map_err(PipelineError::VerifyL0)?;

    // Codegen
    let mc = codegen::codegen(&l0).map_err(PipelineError::Codegen)?;

    // Execute
    let result = codegen::execute(&mc).map_err(PipelineError::Codegen)?;

    let ir = PipelineIR {
        l1,
        l0,
        machine_code: mc,
    };

    Ok((result, ir))
}

/// Dump all intermediate representations for a given DSL input.
/// Returns a human-readable string showing L1 IR, L0 IR, and x86-64 hex.
pub fn dump_ir(source: &str) -> Result<String, PipelineError> {
    let l1 = parser::parse(source).map_err(PipelineError::Parse)?;
    verify_l1::verify(&l1).map_err(PipelineError::VerifyL1)?;
    let l0 = emit::emit(&l1).map_err(PipelineError::Emit)?;
    verify_l0::verify(&l0).map_err(PipelineError::VerifyL0)?;
    let mc = codegen::codegen(&l0).map_err(PipelineError::Codegen)?;

    let mut out = String::new();

    out.push_str("========== L1 IR ==========\n");
    out.push_str(&format!("{}", l1));
    out.push('\n');

    out.push_str("========== L0 IR ==========\n");
    out.push_str(&format!("{}", l0));
    out.push('\n');

    out.push_str("========== x86-64 Machine Code ==========\n");
    out.push_str(&mc.hex_dump());
    out.push('\n');

    Ok(out)
}

/// Run the full verification pipeline: parse → L1 verify → emit → L0 verify → translate validate → report.
///
/// Returns the verification report containing results from all three validation tools.
pub fn verify_translation(source: &str) -> Result<VerificationReport, PipelineError> {
    // Parse
    let l1 = parser::parse(source).map_err(PipelineError::Parse)?;

    // Verify L1
    verify_l1::verify(&l1).map_err(PipelineError::VerifyL1)?;

    // Emit L0 IR
    let l0 = emit::emit(&l1).map_err(PipelineError::Emit)?;

    // Verify L0
    verify_l0::verify(&l0).map_err(PipelineError::VerifyL0)?;

    // Translation validation
    let report = translate_validate::validate(&l1, &l0);

    if !report.all_passed() {
        return Err(PipelineError::TranslationValidation(format!("{}", report)));
    }

    Ok(report)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn counter_end_to_end() {
        let source = include_str!("../examples/counter.l1");
        let (result, _ir) = run(source).expect("counter pipeline should succeed");
        let count = result.read_u64("counter_state", 0).expect("should read counter_state");
        assert_eq!(count, 5, "counter should be 5 after 5 steps");
    }

    #[test]
    fn window_end_to_end() {
        let source = include_str!("../examples/window.l1");
        let (result, _ir) = run(source).expect("window pipeline should succeed");
        let total = result.read_u64("accumulator_state", 0).expect("should read accumulator_state");
        assert_eq!(total, 30, "total should be 30 after 3 steps of Add(10)");
        let observed = result.read_output_values();
        assert_eq!(observed, vec![10, 20, 30], "observed values should be [10, 20, 30]");
    }

    #[test]
    fn counter_ir_dump() {
        let source = include_str!("../examples/counter.l1");
        let dump = dump_ir(source).expect("dump should succeed");
        assert!(dump.contains("========== L1 IR =========="));
        assert!(dump.contains("========== L0 IR =========="));
        assert!(dump.contains("========== x86-64 Machine Code =========="));
        assert!(dump.contains("actor counter"));
        assert!(dump.contains("=== Regions ==="));
        assert!(dump.contains("counter_state"));
    }

    #[test]
    fn window_ir_dump() {
        let source = include_str!("../examples/window.l1");
        let dump = dump_ir(source).expect("dump should succeed");
        assert!(dump.contains("========== L1 IR =========="));
        assert!(dump.contains("accumulator"));
        assert!(dump.contains("output"));
    }

    #[test]
    fn counter_test_vector_full_pipeline() {
        // Full test vector: DSL source -> L1 IR -> L0 IR -> x86-64 -> result
        let source = include_str!("../examples/counter.l1");
        let (result, ir) = run(source).expect("pipeline should succeed");

        // 1. DSL source is the counter.l1 file (inlined via include_str!)
        assert!(source.contains("actor counter"));
        assert!(source.contains("on Increment(amount: u64)"));
        assert!(source.contains("steps: 5"));

        // 2. Expected L1 IR text
        let l1_text = format!("{}", ir.l1);
        assert!(l1_text.contains("actor counter {"));
        assert!(l1_text.contains("count: u64 = 0"));
        assert!(l1_text.contains("window count_view : (count) readers(display)"));
        assert!(l1_text.contains("on Increment(amount: u64) { count = (count + amount) }"));
        assert!(l1_text.contains("leaf ticker {"));
        assert!(l1_text.contains("forward(counter, Increment(1))"));
        assert!(l1_text.contains("leaf display {"));
        assert!(l1_text.contains("pipeline main { ticker -> counter -> display }"));
        assert!(l1_text.contains("steps: 5"));

        // 3. Expected L0 IR text
        let l0_text = format!("{}", ir.l0);
        assert!(l0_text.contains("=== Regions ==="));
        assert!(l0_text.contains("region counter_state : 8 bytes, rw, state"));
        assert!(l0_text.contains("queue"));
        assert!(l0_text.contains("region step_counter : 8 bytes, rw, control"));
        assert!(l0_text.contains("=== Blocks ==="));
        assert!(l0_text.contains("entry:"));
        assert!(l0_text.contains("loop_check:"));
        assert!(l0_text.contains("step:"));
        assert!(l0_text.contains("exit:"));
        assert!(l0_text.contains("load.64"));
        assert!(l0_text.contains("store.64"));
        assert!(l0_text.contains("cmp.lt"));
        assert!(l0_text.contains("branch"));
        assert!(l0_text.contains("queue_push"));
        assert!(l0_text.contains("queue_pop"));
        assert!(l0_text.contains("terminate"));

        // 4. Expected x86-64 bytes (non-empty hex string)
        let hex = ir.machine_code.hex_dump();
        assert!(!hex.is_empty(), "machine code should not be empty");
        // Verify it ends with ret (c3) preceded by the epilogue pops
        assert!(hex.contains("c3"), "machine code should contain ret instruction");

        // 5. Expected execution result
        let count = result.read_u64("counter_state", 0).unwrap();
        assert_eq!(count, 5, "counter should equal step count (5)");
    }

    #[test]
    fn window_test_vector_full_pipeline() {
        // Full test vector: DSL source -> L1 IR -> L0 IR -> x86-64 -> result
        let source = include_str!("../examples/window.l1");
        let (result, ir) = run(source).expect("pipeline should succeed");

        // 1. DSL source
        assert!(source.contains("actor accumulator"));
        assert!(source.contains("on Add(value: u64)"));
        assert!(source.contains("steps: 3"));

        // 2. Expected L1 IR text
        let l1_text = format!("{}", ir.l1);
        assert!(l1_text.contains("actor accumulator {"));
        assert!(l1_text.contains("total: u64 = 0"));
        assert!(l1_text.contains("window total_view : (total) readers(observe)"));
        assert!(l1_text.contains("on Add(value: u64) { total = (total + value) }"));
        assert!(l1_text.contains("leaf source {"));
        assert!(l1_text.contains("forward(accumulator, Add(10))"));
        assert!(l1_text.contains("leaf observe {"));
        assert!(l1_text.contains("emit(total)"));
        assert!(l1_text.contains("pipeline main { source -> accumulator -> observe }"));
        assert!(l1_text.contains("steps: 3"));

        // 3. Expected L0 IR text
        let l0_text = format!("{}", ir.l0);
        assert!(l0_text.contains("region accumulator_state : 8 bytes, rw, state"));
        assert!(l0_text.contains("region output :"));
        assert!(l0_text.contains("output"));
        assert!(l0_text.contains("entry:"));
        assert!(l0_text.contains("queue_push output"));

        // 4. x86-64 bytes
        let hex = ir.machine_code.hex_dump();
        assert!(!hex.is_empty());
        assert!(hex.contains("c3"));

        // 5. Expected execution result
        let total = result.read_u64("accumulator_state", 0).unwrap();
        assert_eq!(total, 30, "total should be 30");
        let observed = result.read_output_values();
        assert_eq!(observed, vec![10, 20, 30], "observed values should be [10, 20, 30]");
    }

    #[test]
    fn pipeline_error_on_invalid_input() {
        let result = run("invalid garbage input");
        assert!(result.is_err());
    }

    #[test]
    fn verify_translation_counter() {
        let source = include_str!("../examples/counter.l1");
        let report = verify_translation(source).expect("counter verification should pass");
        assert!(report.all_passed());
        assert_eq!(report.results.len(), 3);
    }

    #[test]
    fn verify_translation_window() {
        let source = include_str!("../examples/window.l1");
        let report = verify_translation(source).expect("window verification should pass");
        assert!(report.all_passed());
    }

    #[test]
    fn verify_translation_product() {
        let source = include_str!("../examples/product.l1");
        let report = verify_translation(source).expect("product verification should pass");
        assert!(report.all_passed());
    }

    #[test]
    fn verify_translation_invalid_input() {
        let result = verify_translation("invalid garbage");
        assert!(result.is_err());
    }
}