organic/src/wasm_test/compare.rs

use std::borrow::Cow;

use super::elisp_compare::WasmElispCompare;
use crate::compare::Token;
use crate::wasm::WasmAstNode;
use crate::wasm::WasmDocument;

pub fn wasm_compare_document<'b, 's, 'p>(
    source: &'s str,
    emacs: &'b Token<'s>,
    wasm: WasmDocument<'s, 'p>,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
    wasm.compare_ast_node(source, emacs)
}

#[derive(Debug)]
pub struct WasmDiffResult<'s> {
    status: Vec<WasmDiffStatus>,
    name: Cow<'s, str>,
    children: Vec<WasmDiffResult<'s>>,
}

#[derive(Debug)]
pub(crate) enum WasmDiffStatus {
    Good,
    Bad(Cow<'static, str>),
}

impl<'s> WasmDiffResult<'s> {
    // fn apply(
    //     &self,
    //     status: &mut WasmDiffStatus,
    //     children: &mut Vec<WasmDiffEntry<'s>>,
    // ) -> Result<WasmDiffEntry<'s>, Box<dyn std::error::Error>> {
    //     todo!()
    // }

    fn extend(
        &mut self,
        other: WasmDiffResult<'s>,
    ) -> Result<&mut WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        if self.name.is_empty() {
            self.name = other.name;
        }
        self.status.extend(other.status);
        self.children.extend(other.children);
        Ok(self)
    }

    pub fn is_bad(&self) -> bool {
        todo!()
        // self.is_immediately_bad() || self.has_bad_children()
    }

    pub fn print(&self, original_document: &str) -> Result<(), Box<dyn std::error::Error>> {
        // self.print_indented(0, original_document)
        todo!()
    }
}

impl<'s> Default for WasmDiffResult<'s> {
    fn default() -> Self {
        WasmDiffResult {
            status: Vec::new(),
            name: "".into(),
            children: Vec::new(),
        }
    }
}

// impl<'s> WasmDiffEntry<'s> {
//     // fn has_bad_children(&self) -> bool {
//     //     match self {
//     //         DiffEntry::DiffResult(diff) => &diff.children,
//     //         DiffEntry::DiffLayer(diff) => &diff.children,
//     //     }
//     //     .iter()
//     //     .any(|child| child.is_immediately_bad() || child.has_bad_children())
//     // }

//     // fn is_immediately_bad(&self) -> bool {
//     //     match self {
//     //         DiffEntry::DiffResult(diff) => matches!(diff.status, DiffStatus::Bad),
//     //         DiffEntry::DiffLayer(_) => false,
//     //     }
//     // }

//     pub fn is_bad(&self) -> bool {
//         todo!()
//         // self.is_immediately_bad() || self.has_bad_children()
//     }

//     pub fn print(&self, original_document: &str) -> Result<(), Box<dyn std::error::Error>> {
//         self.print_indented(0, original_document)
//     }

//     fn print_indented(
//         &self,
//         indentation: usize,
//         original_document: &str,
//     ) -> Result<(), Box<dyn std::error::Error>> {
//         todo!()
//         // match self {
//         //     WasmDiffEntry::WasmDiffResult(diff) => {
//         //         diff.print_indented(indentation, original_document)
//         //     }
//         //     WasmDiffEntry::WasmDiffLayer(diff) => {
//         //         diff.print_indented(indentation, original_document)
//         //     }
//         // }
//     }
// }

fn wasm_compare_list<'b, 's: 'b, 'p, EI, WI, WC>(
    source: &'s str,
    emacs: EI,
    wasm: WI,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>>
where
    EI: Iterator<Item = &'b Token<'s>> + ExactSizeIterator,
    WI: Iterator<Item = WC> + ExactSizeIterator,
    WC: WasmElispCompare<'s, 'p>,
{
    let status = Vec::new();
    let emacs_length = emacs.len();
    let wasm_length = wasm.len();
    if emacs_length != wasm_length {
        return Ok(WasmDiffResult {
            status: vec![WasmDiffStatus::Bad(
                format!(
                    "Child length mismatch (emacs != rust) {:?} != {:?}",
                    emacs_length, wasm_length
                )
                .into(),
            )],
            children: Vec::new(),
            name: "".into(),
        });
    }

    let mut child_status = Vec::with_capacity(emacs_length);
    for (emacs_child, wasm_child) in emacs.zip(wasm) {
        child_status.push(wasm_child.compare_ast_node(source, emacs_child)?);
    }
    Ok(WasmDiffResult {
        status,
        children: child_status,
        name: "".into(),
    })
}

impl<'s, 'p, WAN: WasmElispCompare<'s, 'p>> WasmElispCompare<'s, 'p> for &WAN {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        (*self).compare_ast_node(source, emacs)
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmAstNode<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        todo!()
    }
}

impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDocument<'s, 'p> {
    fn compare_ast_node<'b>(
        &self,
        source: &'s str,
        emacs: &'b Token<'s>,
    ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
        let mut result = WasmDiffResult::default();
        let emacs_children = emacs.as_list()?.iter().skip(2);
        let wasm_children = self.children.iter();
        result.extend(wasm_compare_list(source, emacs_children, wasm_children)?)?;
        todo!()
    }
}