pub mod token;
pub mod lexer;
pub mod ast;
pub mod parser;
pub mod types;
pub mod symbols;
pub mod collector;
pub mod resolver;
pub mod resolve;
pub mod typecheck;
pub mod lowering;
pub mod contracts;

pub use collector::SymbolCollector;
pub use lexer::Lexer;
pub use lowering::Lowerer;
pub use resolver::{ModuleProvider, Resolver};
pub use symbols::{ModuleSymbols, Namespace, Symbol, SymbolKind, SymbolTable, Visibility};
pub use token::{Token, TokenKind};
pub use typecheck::TypeChecker;

use crate::common::diagnostics::DiagnosticBundle;
use crate::common::files::FileManager;
use crate::frontends::Frontend;
use crate::ir_vm;
use crate::lowering::core_to_vm;
use prometeu_analysis::NameInterner;
use std::path::Path;

pub struct PbsFrontend;

impl Frontend for PbsFrontend {
    fn language(&self) -> &'static str {
        "pbs"
    }

    fn compile_to_ir(
        &self,
        entry: &Path,
        file_manager: &mut FileManager,
    ) -> Result<ir_vm::Module, DiagnosticBundle> {
        let source = std::fs::read_to_string(entry).map_err(|e| {
            DiagnosticBundle::error(format!("Failed to read file: {}", e), None)
        })?;
        let file_id = file_manager.add(entry.to_path_buf(), source.clone());

        let mut interner = NameInterner::new();
        let mut parser = parser::Parser::new(&source, file_id, &mut interner);
        let parsed = parser.parse_file()?;

        let mut collector = SymbolCollector::new(&interner);
        let (type_symbols, value_symbols) =
            collector.collect(&parsed.arena, parsed.root)?;
        let mut module_symbols = ModuleSymbols { type_symbols, value_symbols };

        struct EmptyProvider;
        impl ModuleProvider for EmptyProvider {
            fn get_module_symbols(&self, _path: &str) -> Option<&ModuleSymbols> { None }
        }

        let mut resolver = Resolver::new(&module_symbols, &EmptyProvider, &interner);
        resolver.resolve(&parsed.arena, parsed.root)?;
        let imported_symbols = resolver.imported_symbols;

        let mut typechecker = TypeChecker::new(&mut module_symbols, &imported_symbols, &EmptyProvider, &interner);
        typechecker.check(&parsed.arena, parsed.root)?;

        // Lower to Core IR
        let lowerer = Lowerer::new(&parsed.arena, &module_symbols, &imported_symbols, &interner);
        let module_name = entry.file_stem().unwrap().to_string_lossy();
        let core_program = lowerer.lower_file(parsed.root, &module_name)?;

        // Validate Core IR Invariants
        crate::ir_core::validate_program(&core_program).map_err(|e| {
            DiagnosticBundle::error(format!("Core IR Invariant Violation: {}", e), None)
        })?;

        // Lower Core IR to VM IR
        core_to_vm::lower_program(&core_program).map_err(|e| {
            DiagnosticBundle::error(format!("Lowering error: {}", e), None)
        })
    }
}