main.rs

use anyhow::{Context, Result};
use chardetng::EncodingDetector;
use dialoguer::{theme::ColorfulTheme, Select};
use encoding_rs::Encoding;
use ignore::WalkBuilder;
use rayon::prelude::*;
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};

const CONFIG_FILE: &str = "rsfe.conf";
const COMMON_ENCODINGS: &[&str] = &[
    "UTF-8",
    "UTF-16LE",
    "UTF-16BE",
    "ISO-8859-1",
    "WINDOWS-1252",
    "AUTO",
];

#[derive(Debug, Clone)]
struct EncodingRule {
    pattern: glob::Pattern,
    encoding: String,
}

#[derive(Debug)]
struct Config {
    rules: Vec<EncodingRule>,
    default_encoding: String,
}

impl Config {
    fn load(config_path: &Path) -> Result<Self> {
        let content = fs::read_to_string(config_path)
            .with_context(|| format!("Falha ao ler arquivo de configuração: {:?}", config_path))?;

        let mut rules = Vec::new();
        let mut default_encoding = String::from("UTF-8");

        for (line_num, line) in content.lines().enumerate() {
            let line = line.trim();

            // Ignora linhas vazias e comentários
            if line.is_empty() || line.starts_with('#') {
                continue;
            }

            let parts: Vec<&str> = line.split_whitespace().collect();
            if parts.len() != 2 {
                eprintln!("Aviso: Linha {} ignorada (formato inválido): {}", line_num + 1, line);
                continue;
            }

            let pattern_str = parts[0];
            let encoding = parts[1].to_uppercase();

            // Valida encoding
            if encoding != "AUTO" && Encoding::for_label(encoding.as_bytes()).is_none() {
                eprintln!("Aviso: Encoding desconhecido '{}' na linha {}", encoding, line_num + 1);
                continue;
            }

            if pattern_str == "**" {
                default_encoding = encoding.clone();
            } else {
                match glob::Pattern::new(pattern_str) {
                    Ok(pattern) => rules.push(EncodingRule { pattern, encoding }),
                    Err(e) => {
                        eprintln!("Aviso: Padrão inválido '{}' na linha {}: {}", pattern_str, line_num + 1, e);
                    }
                }
            }
        }

        Ok(Config {
            rules,
            default_encoding,
        })
    }

   fn get_encoding_for_file(&self, file_path: &Path) -> &str {
        // Primeiro tenta usar o caminho relativo ao cwd
        let path_str = if file_path.is_absolute() {
            std::env::current_dir()
                .ok()
                .and_then(|cwd| file_path.strip_prefix(&cwd).ok())
                .map(|p| p.to_string_lossy().to_string())
                .unwrap_or_else(|| file_path.to_string_lossy().to_string())
        } else {
            file_path.to_string_lossy().to_string()
        };

        for rule in &self.rules {
            if rule.pattern.matches(&path_str) {
                return &rule.encoding;
            }
        }

        &self.default_encoding
    }
}

fn detect_encoding(content: &[u8]) -> Option<&'static Encoding> {
    let mut detector = EncodingDetector::new();
    detector.feed(content, true);
    Some(detector.guess(None, true))
}

fn convert_encoding(
    file_path: &Path,
    target_encoding_name: &str,
) -> Result<bool> {
    let content = fs::read(file_path)
        .with_context(|| format!("Falha ao ler arquivo: {:?}", file_path))?;

    // Se arquivo está vazio, não precisa converter
    if content.is_empty() {
        return Ok(false);
    }

    let target_encoding = if target_encoding_name == "AUTO" {
        detect_encoding(&content).unwrap_or(encoding_rs::UTF_8)
    } else {
        Encoding::for_label(target_encoding_name.as_bytes())
            .unwrap_or(encoding_rs::UTF_8)
    };

    // Detecta o encoding atual
    let current_encoding = detect_encoding(&content).unwrap_or(encoding_rs::UTF_8);

    // Tenta decodificar o arquivo com o encoding alvo para verificar se já está correto
    let (decoded_target, _, had_errors_target) = target_encoding.decode(&content);

    if !had_errors_target {
        // Verifica se ao recodificar obtemos exatamente o mesmo conteúdo
        let (reencoded, _, _) = target_encoding.encode(&decoded_target);

        // Se o conteúdo é idêntico E o encoding detectado é compatível com o alvo,
        // considera que já está no encoding correto
        if reencoded.as_ref() == content {
            // Verifica se o encoding atual é realmente o mesmo do alvo
            // (evita falsos positivos com encodings compatíveis)
            let is_same_encoding = current_encoding.name() == target_encoding.name() ||
                (target_encoding.name() == "windows-1252" && current_encoding.name().starts_with("windows")) ||
                (target_encoding.name().starts_with("ISO-8859") && current_encoding.name().starts_with("ISO-8859"));

            if is_same_encoding {
                return Ok(false);
            }
        }
    }

    // Decodifica do encoding detectado
    let (decoded, _, had_errors) = current_encoding.decode(&content);

    if had_errors {
        eprintln!(
            "Aviso: Erros ao decodificar {:?} de {:?}",
            file_path, current_encoding.name()
        );
    }

    // Codifica para o encoding alvo
    let (encoded, _, encode_errors) = target_encoding.encode(&decoded);

    if encode_errors {
        eprintln!(
            "Aviso: Erros ao codificar {:?} para {:?}",
            file_path, target_encoding.name()
        );
    }

    // Escreve o arquivo convertido
    let mut file = fs::File::create(file_path)
        .with_context(|| format!("Falha ao criar arquivo: {:?}", file_path))?;

    file.write_all(&encoded)
        .with_context(|| format!("Falha ao escrever arquivo: {:?}", file_path))?;

    println!(
        "✓ Convertido: {:?} ({:?} → {:?})",
        file_path,
        current_encoding.name(),
        target_encoding.name()
    );

    Ok(true)
}

fn prompt_default_encoding() -> Result<String> {
    println!("\nArquivo de configuração 'rsfe.conf' não encontrado.");
    println!("Selecione o encoding padrão para os arquivos do projeto:\n");

    let selection = Select::with_theme(&ColorfulTheme::default())
        .items(COMMON_ENCODINGS)
        .default(0)
        .interact()?;

    Ok(COMMON_ENCODINGS[selection].to_string())
}

fn get_staged_files() -> Result<Vec<PathBuf>> {
    // Tenta obter arquivos do stage do git
    let output = std::process::Command::new("git")
        .args(&["diff", "--cached", "--name-only", "--diff-filter=ACM"])
        .output();

    match output {
        Ok(output) if output.status.success() => {
            let files = String::from_utf8_lossy(&output.stdout)
                .lines()
                .map(|s| PathBuf::from(s.trim()))
                .filter(|p| p.exists() && p.is_file())
                .collect();
            Ok(files)
        }
        _ => {
            // Se não estiver em um repositório git ou não houver arquivos staged,
            // processa todos os arquivos do projeto
            Ok(Vec::new())
        }
    }
}

fn collect_files(base_path: &Path, specific_files: Option<Vec<PathBuf>>) -> Vec<PathBuf> {
    if let Some(files) = specific_files {
        if !files.is_empty() {
            return files;
        }
    }

    // Usa ignore/WalkBuilder para respeitar .gitignore
    WalkBuilder::new(base_path)
        .hidden(false)
        .git_ignore(true)
        .filter_entry(|entry| {
            let path = entry.path();
            // Ignora diretórios comuns
            if path.is_dir() {
                let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
                return !matches!(
                    name,
                    "node_modules" | "target" | "dist" | "build" | ".git" | ".idea" | ".vscode"
                );
            }
            true
        })
        .build()
        .filter_map(|entry| entry.ok())
        .filter(|entry| entry.path().is_file())
        .map(|entry| entry.path().to_path_buf())
        .collect()
}

fn process_files(config: &Config, files: Vec<PathBuf>) -> Result<()> {
    let results: Vec<_> = files
        .par_iter()
        .filter_map(|file_path| {
            // Ignora arquivos binários comuns
            if let Some(ext) = file_path.extension() {
                let ext = ext.to_string_lossy().to_lowercase();
                if matches!(
                    ext.as_str(),
                    "png" | "jpg" | "jpeg" | "gif" | "pdf" | "zip" | "tar" | "gz" | "exe" | "dll" | "so" | "dylib"
                ) {
                    return None;
                }
            }

            let target_encoding = config.get_encoding_for_file(file_path);

            match convert_encoding(file_path, target_encoding) {
                Ok(converted) => Some((file_path.clone(), target_encoding.to_string(), converted)),
                Err(e) => {
                    eprintln!("Erro ao processar {:?}: {}", file_path, e);
                    None
                }
            }
        })
        .collect();

    let converted_count: usize = results.iter().map(|(_, _, converted)| if *converted { 1 } else { 0 }).sum();

    println!(
        "\n{} arquivo(s) convertido(s) de {} processado(s)",
        converted_count,
        results.len()
    );

    Ok(())
}

fn main() -> Result<()> {
    println!("🔍 RSFE - Rust Source File Encoding Fixer\n");
    
    let current_dir = std::env::current_dir()?;
    let config_path = current_dir.join(CONFIG_FILE);

    let config = if config_path.exists() {
        println!("📋 Carregando configuração de: {:?}\n", config_path);
        Config::load(&config_path)?
    } else {
        let default_encoding = prompt_default_encoding()?;
        println!("\n✓ Usando encoding padrão: {}\n", default_encoding);

        Config {
            rules: Vec::new(),
            default_encoding,
        }
    };

    // Tenta obter arquivos staged do git
    let staged_files = get_staged_files()?;

    let files = if !staged_files.is_empty() {
        println!("📦 Processando {} arquivo(s) staged para commit\n", staged_files.len());
        staged_files
    } else {
        println!("📂 Processando todos os arquivos do projeto\n");
        collect_files(&current_dir, None)
    };

    if files.is_empty() {
        println!("ℹ️  Nenhum arquivo para processar");
        return Ok(());
    }

    process_files(&config, files)?;

    println!("\n✅ Processamento concluído!");
    Ok(())
}