ccat 0.1.1

use super::{Diagnostic, DiagnosticLevel, DiagnosticResult, PerformanceMetrics};
use crate::core::MemoryFile;
use anyhow::Result;

pub struct Diagnostics {
    strict: bool,
}

impl Default for Diagnostics {
    fn default() -> Self {
        Self::new()
    }
}

impl Diagnostics {
    pub fn new() -> Self {
        Self { strict: false }
    }

    pub fn with_strict(mut self, strict: bool) -> Self {
        self.strict = strict;
        self
    }

    pub fn check(&self, files: &[MemoryFile]) -> Result<DiagnosticResult> {
        let mut errors = Vec::new();
        let mut warnings = Vec::new();
        let suggestions = Vec::new();

        // Basic checks
        for file in files {
            // Check file size
            if file.metadata.size > 1_000_000 {
                warnings.push(Diagnostic {
                    level: DiagnosticLevel::Warning,
                    message: format!("File is larger than 1MB: {}", file.path.display()),
                    file: Some(file.path.to_string_lossy().to_string()),
                    line: None,
                    code: "large-file".to_string(),
                });
            }

            // Check for missing imports
            for import in &file.imports {
                if import.resolved_path.is_none() {
                    errors.push(Diagnostic {
                        level: DiagnosticLevel::Error,
                        message: format!("Unresolved import: {}", import.path),
                        file: Some(file.path.to_string_lossy().to_string()),
                        line: Some(import.line_number),
                        code: "missing-import".to_string(),
                    });
                }
            }
        }

        let metrics = PerformanceMetrics {
            total_files: files.len(),
            total_size: files.iter().map(|f| f.metadata.size).sum(),
            import_depth: 0,     // TODO: Calculate actual import depth
            circular_imports: 0, // TODO: Detect circular imports
        };

        Ok(DiagnosticResult {
            errors,
            warnings,
            suggestions,
            metrics,
        })
    }
}