use std::path;

use thiserror::Error;

use crate::{
    converter, generator,
    io::{get_xml_gitinfo, XmlGitInfoError},
    types,
};

#[derive(Debug, Error)]
pub enum Error {
    #[error("error in getting xml git info: {0}")]
    XmlGitInfoError(#[from] XmlGitInfoError),
    #[error("io error: {0}")]
    IOError(#[from] std::io::Error),
    #[error("xml parse error: {0}")]
    XmlParseError(#[from] roxmltree::Error),
    #[error("dom conversion error: {0}")]
    DomConversionError(#[from] converter::DomConversionError),
    #[error("code generation error: {0}")]
    CodeGenError(#[from] generator::CodeGenError),
}

/// Generate register interface code from xml in `xml` and write them under directory `out`.
pub fn generate(xml: &path::Path, out: &path::Path) -> Result<(), Error> {
    log::debug!("generate called: xml:{:?}, out: {:?}", xml, out);

    let xml_git_info = get_xml_gitinfo(xml)?;
    log::debug!("xml git info {xml_git_info:?}");

    let xmlfile = std::fs::read_to_string(xml)?;
    let doc = roxmltree::Document::parse_with_options(
        &xmlfile,
        roxmltree::ParsingOptions {
            allow_dtd: true,
            nodes_limit: u32::MAX,
        },
    )?;
    log::debug!("xml parsed {doc:?}");

    let register_map = types::Module::from_xml_dom(doc.root_element(), xml_git_info)?;
    log::debug!("converted {register_map:?}");

    let files = register_map.generate_code()?;
    if log::log_enabled!(log::Level::Debug) {
        for (path, code) in &files {
            log::debug!("path: {:?}", path);
            log::debug!("{}", prettyplease::unparse(code));
            log::trace!("{}", prettyplease::unparse(code));
        }
    }

    crate::write_to_files(files, out)?;
    log::debug!("wrote to files");

    Ok(())
}