use crate::cli::CompilerConfig;
use crate::generator::prelude::*;
use crate::lexer::{LexerRenderModel, render_lexer_model};
use crate::optimization::OptimizationPlan;
use crate::parser::{ParserRenderOptions, render_parser_with_decision_report};
use crate::semantics::{
    DecisionReportGrammar, GrammarOptionEntry, SemanticsEntry, collect_lexer_semantics,
    collect_parser_semantics_for_mode, collect_structural_grammar_options,
    enforce_require_full_options, enforce_require_full_semantics, enforce_sem_unknown,
    grammar_option_warning_messages, render_decisions_manifest, render_semantics_manifest,
};

pub(crate) fn generate(
    args: &CompilerConfig,
    mut report: impl FnMut(&str) -> io::Result<()>,
) -> Result<Generation, Error> {
    let optimizations = OptimizationPlan::from_compiler_config(args)?;
    let action_reference_parser: grammar::action::ActionReferenceParser = if args.embedded_actions {
        embedded::action_references
    } else {
        grammar::action::action_references
    };
    let compilation = grammar::compiler::compile_with_action_reference_parser(
        LoadOptions {
            roots: args.roots.clone(),
            library_directories: args.library_directories.clone(),
        },
        optimizations.transforms(),
        optimizations.report_only(),
        optimizations.entry_rules(),
        action_reference_parser,
    )
    .map_err(|error| compilation_error(&error, &args.roots))?;
    let mut warnings = compilation_warning_messages(&compilation);
    for warning in &warnings {
        report(warning).map_err(Error::generation)?;
    }
    let optimization_messages = optimizations.diagnostic_messages(&compilation);
    for message in &optimization_messages {
        report(message).map_err(Error::generation)?;
    }
    warnings.extend(optimization_messages);
    let inputs = compilation
        .sources
        .canonical_paths()
        .map(Path::to_path_buf)
        .collect::<Vec<_>>();
    let optimization_manifest = optimizations.render_manifest(&compilation);
    if optimizations.report_only() {
        let mut artifacts = GeneratedArtifacts::default();
        artifacts.insert(
            "optimizations.json",
            optimization_manifest.expect("report mode enables the optimization manifest"),
        )?;
        let outputs = artifacts.write_to(&args.out_dir)?;
        return Ok(Generation::new(inputs, outputs, warnings));
    }

    let mut grammar_options = Vec::new();
    let mut manifest_grammars: Vec<(&'static str, String, Vec<SemanticsEntry>)> = Vec::new();
    let mut decision_report_grammars: Vec<DecisionReportGrammar> = Vec::new();
    let mut rendered_modules = BTreeMap::<PathBuf, String>::new();
    let mut emitted_lexers = BTreeSet::new();
    let mut emitted_parsers = BTreeSet::new();

    for root in &compilation.roots {
        if let Some(grammar) = root.lexer
            && emitted_lexers.insert(grammar)
        {
            let compiled = compilation
                .lexer(grammar)
                .expect("compiled root lexer artifact exists");
            let data = LexerCodegenData::from_compiled(compiled, &compilation.sources);
            grammar_options.extend(collect_structural_grammar_options(
                &data,
                &args.option_hooks,
            )?);
            let entries = collect_lexer_semantics(
                &data,
                args.embedded_actions,
                args.allow_unsupported_lexer_actions,
                args.sem_unknown,
                &args.sem_patterns,
            )?;
            enforce_sem_unknown(args.sem_unknown, &entries)?;
            enforce_require_full_semantics(args.require_full_semantics, &entries)?;
            let grammar_name = compiled.semantic.recognizer.name.clone();
            let render_model = LexerRenderModel::new(
                &grammar_name,
                &data,
                args.allow_unsupported_lexer_actions,
                args.sem_unknown,
                &args.sem_patterns,
                args.embedded_actions,
            );
            let module = render_lexer_model(&render_model)?;
            insert_rendered_module(&mut rendered_modules, &grammar_name, module)?;
            manifest_grammars.push(("lexer", grammar_name, entries));
        }

        if let Some(grammar) = root.parser
            && emitted_parsers.insert(grammar)
        {
            let compiled = compilation
                .parser(grammar)
                .expect("compiled root parser artifact exists");
            let data = ParserCodegenData::from_compiled(compiled, &compilation.sources);
            grammar_options.extend(collect_structural_grammar_options(
                &data,
                &args.option_hooks,
            )?);
            let entries = collect_parser_semantics_for_mode(
                &data,
                args.embedded_actions,
                args.sem_unknown,
                &args.sem_patterns,
            )?;
            enforce_sem_unknown(args.sem_unknown, &entries)?;
            enforce_require_full_semantics(args.require_full_semantics, &entries)?;
            let grammar_name = compiled.semantic.recognizer.name.clone();
            let (module, decision_report_rows) = render_parser_with_decision_report(
                &grammar_name,
                &data,
                ParserRenderOptions {
                    require_generated_parser: args.require_generated_parser,
                    embedded: args.embedded_actions,
                    generate_listener: args.generate_listener,
                    generate_visitor: args.generate_visitor,
                    sem_unknown: args.sem_unknown,
                    patterns: Some(&args.sem_patterns),
                    fixed_lookahead: args.fixed_lookahead,
                },
            )?;
            insert_rendered_module(&mut rendered_modules, &grammar_name, module)?;
            decision_report_grammars.push(DecisionReportGrammar {
                name: grammar_name.clone(),
                rule_names: data.rule_names.clone(),
                rows: decision_report_rows,
            });
            manifest_grammars.push(("parser", grammar_name, entries));
        }
    }

    deduplicate_grammar_options(&mut grammar_options);
    let option_warnings = grammar_option_warning_messages(&grammar_options);
    for warning in &option_warnings {
        report(warning).map_err(Error::generation)?;
    }
    warnings.extend(option_warnings);
    enforce_require_full_options(args.require_full_semantics, &grammar_options)?;
    let manifest =
        render_semantics_manifest(args.sem_unknown, &grammar_options, &manifest_grammars);

    let mut artifacts = GeneratedArtifacts::default();
    for (path, module) in rendered_modules {
        artifacts.insert(path, module)?;
    }
    artifacts.insert("semantics.json", manifest)?;
    artifacts.insert(
        "decisions.json",
        render_decisions_manifest(args.fixed_lookahead, &decision_report_grammars),
    )?;
    if let Some(manifest) = optimization_manifest {
        artifacts.insert("optimizations.json", manifest)?;
    } else {
        artifacts.remove_if_present("optimizations.json")?;
    }
    let outputs = artifacts.write_to(&args.out_dir)?;
    Ok(Generation::new(inputs, outputs, warnings))
}

fn insert_rendered_module(
    modules: &mut BTreeMap<PathBuf, String>,
    grammar_name: &str,
    module: String,
) -> io::Result<()> {
    let path = PathBuf::from(format!("{}.rs", module_name(grammar_name)));
    match modules.entry(path.clone()) {
        Entry::Vacant(entry) => {
            entry.insert(module);
            Ok(())
        }
        Entry::Occupied(_) => Err(io::Error::new(
            io::ErrorKind::InvalidInput,
            format!(
                "generated module collision for grammar {grammar_name}: {}",
                path.display()
            ),
        )),
    }
}

fn deduplicate_grammar_options(options: &mut Vec<GrammarOptionEntry>) {
    options.sort_by(|left, right| {
        (&left.key, &left.value, left.line, left.column).cmp(&(
            &right.key,
            &right.value,
            right.line,
            right.column,
        ))
    });
    options.dedup_by(|left, right| {
        left.key == right.key
            && left.value == right.value
            && left.line == right.line
            && left.column == right.column
    });
}

fn compilation_error(error: &grammar::diagnostic::CompilationError, roots: &[PathBuf]) -> Error {
    let fallback = roots
        .first()
        .map_or_else(|| Path::new("<grammar>"), PathBuf::as_path);
    let mut message = String::new();
    let mut diagnostics = Vec::with_capacity(error.diagnostics().len());
    for (index, diagnostic) in error.diagnostics().iter().enumerate() {
        let (severity_name, severity) = match diagnostic.severity {
            grammar::diagnostic::Severity::Warning => ("warning", Severity::Warning),
            grammar::diagnostic::Severity::Error => ("error", Severity::Error),
        };
        let location = error.location(index);
        let path =
            location.map_or_else(|| fallback.to_path_buf(), |location| location.path.clone());
        let position = location.and_then(|location| location.position);
        let display_position =
            position.map_or_else(String::new, |(line, column)| format!(":{line}:{column}"));
        let _ = writeln!(
            message,
            "{severity_name}[{}]: {}{display_position}: {}",
            diagnostic.code,
            path.display(),
            diagnostic.message
        );
        diagnostics.push(Diagnostic::new(
            diagnostic.code,
            severity,
            diagnostic.message.clone(),
            path,
            position,
        ));
    }
    Error::compilation(message, diagnostics)
}

fn compilation_warning_messages(compilation: &grammar::compiler::Compilation) -> Vec<String> {
    let mut messages = Vec::new();
    for diagnostic in compilation
        .diagnostics
        .iter()
        .filter(|diagnostic| diagnostic.severity == grammar::diagnostic::Severity::Warning)
    {
        let source = compilation.sources.get(diagnostic.primary.source);
        let path = source.map_or_else(
            || "<grammar>".to_owned(),
            |source| source.logical_path().display().to_string(),
        );
        let position = source
            .and_then(|source| source.line_column(diagnostic.primary.bytes.start))
            .map_or_else(String::new, |(line, column)| format!(":{line}:{column}"));
        messages.push(format!(
            "warning[{}]: {path}{position}: {}",
            diagnostic.code, diagnostic.message
        ));
    }
    messages
}