cli.py

"""Command Line Interface (CLI) for the Workspacescan project.

Parses command-line arguments, validates inputs, and triggers the search
orchestrator across local paths, UNC network shares, Android, Google Drive
and Gmail — individually selectable or combined via --sources.
Suporta modo --report-only para gerar relatórios sobre ficheiros já existentes.
"""

import argparse
import datetime
import os
import sys
import threading
from typing import List, Optional, Set, Tuple

from src.config import OLLAMA_URL
from src.extractor import TextExtractor
from src.reporter import ReportGenerator
from src.searcher import WorkspacescanOrchestrator
from src.utils import is_unc_path, normalize_sources

# Limite de caracteres para extração no modo --report-only (mesma janela de contexto do LLM)
_REPORT_ONLY_TRUNCATION_LIMIT = 3500


class TeeLogger:
    """Redirects stdout and stderr to both the terminal and a timestamped log file."""

    def __init__(self, log_filepath: str):
        """Abre o ficheiro de log e captura o stdout original do terminal."""
        self.terminal = sys.stdout
        self.log_file = open(log_filepath, "w", encoding="utf-8")
        self.new_line = True
        self.lock = threading.Lock()

    def write(self, message: str) -> None:
        """Escreve a mensagem no terminal e no log com timestamp por linha."""
        with self.lock:
            self.terminal.write(message)
            if not message:
                return

            # Filtra frames interativos do tqdm (\r sem \n) para evitar log bloat
            if "\r" in message and "\n" not in message:
                # Grava apenas marcos percentuais significativos (10%, 20%, ..., 100%)
                for milestone in [
                    "100%",
                    "90%",
                    "80%",
                    "70%",
                    "60%",
                    "50%",
                    "40%",
                    "30%",
                    "20%",
                    "10%",
                ]:
                    if milestone in message:
                        clean_line = message.replace("\r", "").strip()
                        if clean_line:
                            timestamp = datetime.datetime.now().strftime("[%Y-%m-%d %H:%M:%S] ")
                            self.log_file.write(f"{timestamp}{clean_line}\n")
                            self.new_line = True
                        break
                self.log_file.flush()
                return

            lines = message.split("\n")
            for i, line in enumerate(lines):
                if i > 0:
                    self.log_file.write("\n")
                    self.new_line = True
                if line:
                    # Remove fragmentos de \r residuais em linhas mistas
                    line = line.replace("\r", "")
                    if self.new_line:
                        timestamp = datetime.datetime.now().strftime("[%Y-%m-%d %H:%M:%S] ")
                        self.log_file.write(timestamp)
                        self.new_line = False
                    self.log_file.write(line)
            self.log_file.flush()

    def flush(self) -> None:
        """Descarrega os buffers do terminal e do ficheiro de log."""
        with self.lock:
            self.terminal.flush()
            self.log_file.flush()


def resolve_selected_sources(
    raw_sources: List[str],
    unc_dirs: Optional[List[str]],
    local_dirs: Optional[List[str]] = None,
) -> Tuple[Set[str], Optional[str]]:
    r"""Resolve os tokens de --sources para o conjunto canônico, validando os caminhos.

    Regras:
    - Aliases 'pc'/'google'/'all' são expandidos por normalize_sources.
    - Informar --unc-dirs ativa a fonte 'unc' automaticamente; cada caminho deve
      ter formato UNC válido (\\\\servidor\\compartilhamento).
    - Informar --local-dirs ativa a fonte 'local' automaticamente (simétrico a
      --unc-dirs), evitando que diretórios sejam silenciosamente ignorados.
    - 'unc' explícito em --sources sem --unc-dirs é erro; 'unc' herdado do
      agregador 'all' sem --unc-dirs é descartado silenciosamente.

    Args:
        raw_sources: Tokens informados em --sources.
        unc_dirs: Caminhos informados em --unc-dirs (ou None).
        local_dirs: Caminhos informados em --local-dirs (ou None).

    Returns:
        Tupla (fontes canônicas selecionadas, mensagem de erro ou None).
    """
    try:
        sources = normalize_sources(raw_sources)
    except ValueError as exc:
        return set(), str(exc)

    explicit_unc = any(token.strip().lower() == "unc" for token in raw_sources)

    # Informar --local-dirs ativa a fonte 'local' (simétrico a --unc-dirs).
    if local_dirs:
        sources.add("local")

    if unc_dirs:
        invalid = [p for p in unc_dirs if not is_unc_path(p)]
        if invalid:
            return set(), (
                "Caminhos UNC inválidos (formato esperado \\\\servidor\\compartilhamento): "
                + ", ".join(invalid)
            )
        sources.add("unc")
    elif "unc" in sources:
        if explicit_unc:
            return set(), (
                "A fonte 'unc' exige --unc-dirs com um ou mais caminhos "
                "\\\\servidor\\compartilhamento."
            )
        # 'unc' herdado do agregador 'all' sem --unc-dirs: sem share para varrer
        sources.discard("unc")

    return sources, None


def main() -> None:
    """Parses command-line arguments and executes the workspaces scan."""
    parser = argparse.ArgumentParser(
        description="Workspacescan - Busca semântica e heurística multi-origem."
    )

    parser.add_argument(
        "-q",
        "--query",
        required=False,
        default="",
        help="Termo ou conceito de busca semântica a ser procurado nos arquivos.",
    )

    parser.add_argument(
        "-d",
        "--dest",
        required=True,
        help="Diretório de destino local onde os arquivos correspondentes serão copiados.",
    )

    parser.add_argument(
        "--start-date",
        default="",
        help="Data inicial de modificação no formato YYYY-MM-DD (opcional).",
    )

    parser.add_argument(
        "--end-date", default="", help="Data final de modificação no formato YYYY-MM-DD (opcional)."
    )

    parser.add_argument(
        "--sources",
        nargs="+",
        default=["all"],
        choices=["all", "local", "unc", "gdrive", "gmail", "android", "pc", "google"],
        help=(
            "Origens a serem escaneadas, combináveis livremente: 'local' (diretórios do PC), "
            "'unc' (compartilhamentos de rede \\\\servidor\\pasta, requer --unc-dirs), "
            "'gdrive' (Google Drive), 'gmail' (anexos do Gmail), 'android' (via ADB) ou "
            "'all' (todas; 'unc' só entra se --unc-dirs for informado). "
            "Aliases retrocompatíveis: 'pc' = local; 'google' = gdrive + gmail. Padrão: all. "
            "Para varrer fotos do Google Photos, exporte-as via Google Takeout para uma pasta "
            "local e use '--sources local'."
        ),
    )

    parser.add_argument(
        "--local-dirs",
        "--pc-dirs",
        dest="local_dirs",
        nargs="+",
        default=None,
        help=(
            "Um ou mais diretórios locais do PC a serem varridos (fonte 'local'). "
            "Se omitido, varre Documentos e Downloads. Alias: --pc-dirs."
        ),
    )

    parser.add_argument(
        "--unc-dirs",
        nargs="+",
        default=None,
        help=(
            "Um ou mais caminhos UNC de rede a serem varridos (fonte 'unc'), "
            "no formato \\\\servidor\\compartilhamento[\\subpasta]. "
            "Informar este argumento ativa automaticamente a fonte 'unc'."
        ),
    )

    parser.add_argument(
        "--android-dirs",
        nargs="+",
        default=["/sdcard/Download", "/sdcard/Documents", "/sdcard/DCIM"],
        help="Diretórios do celular Android a serem varridos via ADB.",
    )

    parser.add_argument(
        "--report-only",
        action="store_true",
        default=False,
        help=(
            "Gera apenas o relatório de sumarização para ficheiros já existentes "
            "no diretório de destino, sem executar varredura."
        ),
    )

    parser.add_argument(
        "--fiscal",
        action="store_true",
        default=False,
        help=(
            "Ativa o classificador estrito de documentos fiscais brasileiros "
            "(NF-e, NFS-e, NFC-e, CT-e). Ignora arquivos não fiscais."
        ),
    )

    parser.add_argument(
        "--model",
        default="llama3",
        help="Modelo do Ollama a ser utilizado para sumarização semântica. Padrão: llama3.",
    )

    args = parser.parse_args()

    # Validação: --query é obrigatório quando não está em modo --report-only nem --fiscal
    if not args.report_only and not args.fiscal and not args.query:
        parser.error(
            "O argumento -q/--query é obrigatório quando não se utiliza --report-only ou --fiscal."
        )

    # Resolve e valida a seleção granular de fontes (local/unc/gdrive/gmail/android)
    unc_dirs = args.unc_dirs
    if unc_dirs:
        unc_dirs = [os.path.normpath(p.replace("/", "\\")) for p in unc_dirs]
    selected_sources, sources_error = resolve_selected_sources(
        args.sources, unc_dirs, args.local_dirs
    )
    if sources_error:
        parser.error(sources_error)

    # Captura a intenção original do usuário antes da mutação fiscal da query,
    # para que os avisos do modo --report-only reflitam o que foi realmente passado.
    user_query_provided = bool(args.query)

    # Mutação dinâmica da query no modo fiscal
    _FISCAL_CANONICAL_TOKENS = (
        "nota fiscal, nfe, nfse, nf-e, nfs-e, nfc-e, cte, ct-e, danfe, danfse"
    )
    if args.fiscal:
        if args.query:
            args.query = f"{args.query}, {_FISCAL_CANONICAL_TOKENS}"
        else:
            args.query = _FISCAL_CANONICAL_TOKENS

    # Validate destination directory
    dest_dir = os.path.abspath(args.dest)
    if not os.path.exists(dest_dir):
        try:
            os.makedirs(dest_dir, exist_ok=True)
        except Exception as e:
            print(f"ERROR: Cannot create destination directory {dest_dir}: {e}")
            sys.exit(1)

    # Initialize TeeLogger to capture all subsequent console/logging outputs
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    log_filename = f"workspacescan_{timestamp}.log"
    log_filepath = os.path.join(dest_dir, log_filename)

    tee = TeeLogger(log_filepath)
    sys.stdout = tee
    sys.stderr = tee

    # Modo exclusivo de geração de relatório (--report-only)
    if args.report_only:
        # --report-only re-extrai o texto do disco e sumariza TODOS os ficheiros
        # suportados do destino; não filtra por --query nem aplica o classificador
        # --fiscal. Avisa o usuário para evitar a expectativa equivocada de filtragem.
        if user_query_provided:
            print("AVISO: --query é ignorado no modo --report-only (sumariza todos os ficheiros).")
        if args.fiscal:
            print("AVISO: --fiscal não se aplica ao modo --report-only e será ignorado.")
        _run_report_only(dest_dir, log_filepath, args.model)
        return

    # Environment validations (executed with active logging)
    android_enabled = "android" in selected_sources
    google_enabled = bool({"gdrive", "gmail"} & selected_sources)

    from src.env_checker import EnvironmentChecker

    checker = EnvironmentChecker()
    env_result = checker.run_all(
        android_enabled=android_enabled,
        google_enabled=google_enabled,
    )
    if env_result is None:
        sys.exit(1)

    # Use resolved models from auto-detection (overrides config defaults)
    resolved_llm = env_result.get("llm_model", "llama3")
    resolved_vlm = env_result.get("vlm_model", "llava")

    # Set default local PC search directories if not specified
    local_dirs = args.local_dirs
    if not local_dirs and "local" in selected_sources:
        home = os.path.expanduser("~")
        local_dirs = [os.path.join(home, "Documents"), os.path.join(home, "Downloads")]

    # Resolve absolute paths for local PC directories
    if local_dirs:
        local_dirs = [os.path.abspath(p) for p in local_dirs]

    fiscal_label = " [MODO FISCAL]" if args.fiscal else ""
    print(f"Starting Workspacescan...{fiscal_label}")
    print(f"  Query: '{args.query}'")
    print(f"  Destination: {dest_dir}")
    print(f"  Sources: {', '.join(sorted(selected_sources))}")
    if "local" in selected_sources and local_dirs:
        print(f"  Local Dirs: {', '.join(local_dirs)}")
    if "unc" in selected_sources and unc_dirs:
        print(f"  UNC Shares: {', '.join(unc_dirs)}")
    print(f"  Date Range: [{args.start_date or 'None'} to {args.end_date or 'None'}]")
    print(f"  Log File: {log_filepath}")
    print(f"  LLM: {resolved_llm} | VLM: {resolved_vlm}")
    if args.fiscal:
        print("  Classificador Fiscal: ATIVO")

    from src.extractor import TextExtractor

    extractor = TextExtractor(
        llm_model=resolved_llm,
        vlm_model=resolved_vlm,
    )
    orchestrator = WorkspacescanOrchestrator(extractor=extractor)
    try:
        orchestrator.run_search(
            query=args.query,
            dest_dir=dest_dir,
            sources=sorted(selected_sources),
            start_date_str=args.start_date,
            end_date_str=args.end_date,
            pc_dirs=local_dirs,
            android_dirs=args.android_dirs,
            unc_dirs=unc_dirs,
            llm_model=resolved_llm,
            fiscal=args.fiscal,
        )
    except KeyboardInterrupt:
        print("\nProcess interrupted by user.")
        sys.exit(1)
    except Exception as e:
        print(f"\nExecution failed: {e}")
        sys.exit(1)


# Extensões suportadas pelo pipeline de extração nativa do TextExtractor
_SUPPORTED_EXTENSIONS = {
    ".txt",
    ".csv",
    ".xml",
    ".md",
    ".json",
    ".yaml",
    ".ini",
    ".pdf",
    ".docx",
    ".xlsx",
    ".png",
    ".jpg",
    ".jpeg",
}


def _run_report_only(dest_dir: str, log_filepath: str, llm_model: str = "llama3") -> None:
    """Executa apenas a geração de relatório sobre ficheiros existentes.

    Varre o diretório de destino, filtra por extensões suportadas,
    e submete cada ficheiro ao ReportGenerator sequencialmente.

    Args:
        dest_dir (str): Diretório contendo os ficheiros a sumarizar.
        log_filepath (str): Caminho do ficheiro de log ativo.
        llm_model (str): Modelo Ollama usado na sumarização. Padrão: "llama3".
    """
    print("=" * 70)
    print("  WORKSPACESCAN - MODO RELATÓRIO (--report-only)")
    print("=" * 70)
    print(f"  Diretório: {dest_dir}")
    print(f"  Log File:  {log_filepath}")
    print()

    # Verificação/Inicialização do serviço Ollama antes de iterar (URL centralizada em config.OLLAMA_URL)
    from src.env_checker import try_start_ollama

    if not try_start_ollama(OLLAMA_URL):
        print(f"ERRO: O serviço Ollama não pôde ser iniciado ou não está ativo em {OLLAMA_URL}")
        print("Inicie o Ollama manualmente antes de gerar o relatório.")
        sys.exit(1)

    # Coleta de ficheiros suportados no diretório
    discovered_files = []
    for entry in os.listdir(dest_dir):
        filepath = os.path.join(dest_dir, entry)
        if not os.path.isfile(filepath):
            continue
        # Ignora relatórios gerados anteriormente na raiz do destino
        if entry.startswith("Relatorio_Workspacescan_"):
            continue
        _, ext = os.path.splitext(entry.lower())
        ext_lower = ext.lower()
        if ext_lower not in _SUPPORTED_EXTENSIONS:
            # Tenta ler os bytes mágicos para identificar o tipo real do arquivo
            from src.utils import detect_extension_by_magic_bytes

            detected_ext = detect_extension_by_magic_bytes(filepath)
            if detected_ext in _SUPPORTED_EXTENSIONS:
                ext_lower = detected_ext

        if ext_lower in _SUPPORTED_EXTENSIONS:
            discovered_files.append({"nome_destino": entry, "origem": "Ficheiro Local"})

    if not discovered_files:
        print(f"Nenhum ficheiro suportado encontrado em: {dest_dir}")
        sys.exit(0)

    print(f"Ficheiros localizados: {len(discovered_files)}")
    print("Gerando relatório executivo...")
    print()

    extractor = TextExtractor()

    # === Fase 1: Pré-extração de texto (CPU/Disco) ===
    print("Fase 1: Extraindo texto dos ficheiros (CPU)...")
    for file_entry in discovered_files:
        filepath = os.path.join(dest_dir, file_entry["nome_destino"])
        try:
            extracted = extractor.extract_text_lightweight(
                filepath, max_chars=_REPORT_ONLY_TRUNCATION_LIMIT
            )
        except Exception:
            extracted = ""
        file_entry["texto_extraido"] = extracted
    print(f"Extração concluída para {len(discovered_files)} ficheiros.")
    print()

    # === Fase 2: Sumarização via LLM (GPU) ===
    print("Fase 2: Sumarizando via Ollama (GPU)...")
    reporter = ReportGenerator(llm_model=llm_model)

    try:
        report_path = reporter.generate_report(discovered_files, dest_dir)
        if report_path:
            print()
            print(f"Relatório salvo em: {report_path}")
        else:
            print("Nenhum ficheiro elegível encontrado para o relatório.")
    except KeyboardInterrupt:
        print("\nProcess interrupted by user.")
        sys.exit(1)
    except Exception as e:
        print(f"\nReport generation failed: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()