#!/usr/bin/env python3
import polars as pl
import re
import argparse
import os
import logging
import hashlib
from blingfire import text_to_sentences
from lingua import Language, LanguageDetectorBuilder
import nltk


# ===================================================================
# ========================== CONFIG =================================
# ===================================================================

EXPORT_SPLIT = False
EXPORT_CSV = False

ADD_ID = True
ADD_CATEGORY = True
ADD_SHA = True
REMOVE_DUPLICATES = True

ROW_LIMIT = 100_000_000
TEXT_COLUMN = "text"

LAST_ID_FILE = "last_id.txt"       # contém o último ID processado
FILE_PATTERN = "train-"
CLEAN_SUFFIX = "_clean_full.parquet"


# ===================================================================
# ====================== NLTK RESOURCES ===============================
# ===================================================================

def ensure_nltk():
    required = ["punkt", "punkt_tab"]
    for r in required:
        try:
            nltk.data.find(f"tokenizers/{r}")
        except LookupError:
            nltk.download(r, quiet=True)
ensure_nltk()


# ===================================================================
# ========================= CLASSIFICAÇÃO =============================
# ===================================================================

INSTRUCT_PREFIX = re.compile(
    r"^(escreva|explique|resuma|liste|crie|gere|monte|defina|descreva|faça|produza|formule|por favor.*(explique|resuma|liste))",
    re.IGNORECASE
)
QUESTION_PATTERN = re.compile(
    r"\?$|^(quem|o que|qual|quando|por que|como)\b",
    re.IGNORECASE
)

def is_factual(text: str):
    if not isinstance(text, str):
        return False
    return (
        len(text.split()) > 40
        and not INSTRUCT_PREFIX.search(text)
        and not QUESTION_PATTERN.search(text)
    )

def classify_text(text: str):
    if not isinstance(text, str):
        return "other"
    t = text.strip()
    if INSTRUCT_PREFIX.search(t):
        return "instruct"
    if QUESTION_PATTERN.search(t):
        return "question"
    if is_factual(t):
        return "factual"
    return "other"


# ===================================================================
# ========================== IDIOMA ==================================
# ===================================================================

DETECTOR = (
    LanguageDetectorBuilder
    .from_languages(Language.PORTUGUESE, Language.ENGLISH, Language.SPANISH)
    .with_preloaded_language_models()
    .build()
)

def is_portuguese(text: str) -> bool:
    if not isinstance(text, str) or len(text) < 20:
        return False
    try:
        lang = DETECTOR.detect_language_of(text)
        conf = DETECTOR.compute_language_confidence(text, lang)
        return lang == Language.PORTUGUESE and conf >= 0.80
    except:
        return False


# ===================================================================
# ========================= REGEX / LIMPEZA ===========================
# ===================================================================

PORN = re.compile(r"pelad|sexo|porn|novinha|xvideos|boquete|anal ", re.IGNORECASE)
CODE = re.compile(r"function\s*\(|</?script|var\s+|document\.write", re.IGNORECASE)
SPAM = re.compile(r"bet365|promo|cadastre-se|inscreva|orçamento|ligue ", re.IGNORECASE)
META = re.compile(r"visualizado|publicado em|conteúdo recente|mostra idioma", re.IGNORECASE)

PATTERNS = [PORN, CODE, SPAM, META]

CPF  = re.compile(r"\b\d{3}\.?\d{3}\.?\d{3}-?\d{2}\b")
RG   = re.compile(r"\b\d{2}\.?\d{3}\.?\d{3}-?[A-Za-z0-9]{1,2}\b")
PHONE = re.compile(r"\b(\(?\d{2}\)?\s?)?\d{4,5}-?\d{4}\b")
EMAIL = re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")
URL   = re.compile(r"https?://\S+|www\.\S+|\b\S+\.(com|net|org|gov|edu)\b")

HEADINGS = re.compile(
    r"^(Categoria:|Veja também:|Leia mais:|Últimas notícias:|Para saber mais:|Este artigo|Esta categoria)",
    re.IGNORECASE
)

def remove_personal(text):
    text = CPF.sub("", text)
    text = RG.sub("", text)
    text = PHONE.sub("", text)
    text = EMAIL.sub("", text)
    text = URL.sub("", text)
    return text

def remove_patterns_func(text):
    if not isinstance(text, str):
        return None
    for p in PATTERNS:
        if p.search(text):
            return None
    return text

def remove_headings_func(text):
    return None if HEADINGS.search(text) else text

def normalize(text):
    if not isinstance(text, str):
        return None
    text = re.sub(r'^[\s\u00A0\u1680\u180E\u2000-\u200A\u202F\u205F\u3000]+', '', text)
    text = remove_personal(text)
    if remove_headings_func(text) is None:
        return None
    text = re.sub(r'\s+', ' ', text)
    text = re.sub(r'[^\w\s.,!?()\-–]', '', text)
    text = text.strip()
    return text if len(text) >= 25 else None

def remove_truncated(text):
    if not isinstance(text, str):
        return None
    if re.match(r"pr[oó]s:|contras:|leia mais|clique|assine", text.lower()):
        return None
    return text

def split_sentences(text):
    raw = text_to_sentences(text)
    return [s.strip() for s in raw.split("\n") if len(s.strip()) > 25]

def compute_sha(text: str):
    if not isinstance(text, str):
        return None
    return hashlib.sha256(text.encode("utf-8")).hexdigest()


# ===================================================================
# ====================== ID MANAGEMENT ================================
# ===================================================================

def load_last_id():
    if not os.path.exists(LAST_ID_FILE):
        with open(LAST_ID_FILE, "w") as f:
            f.write("0")
        return 0

    with open(LAST_ID_FILE, "r") as f:
        try:
            return int(f.read().strip())
        except:
            return 0

def save_last_id(value):
    with open(LAST_ID_FILE, "w") as f:
        f.write(str(value))


# ===================================================================
# ======================= PROCESSAR UM ARQUIVO ========================
# ===================================================================

def process_file(filepath, id_start):

    filename = os.path.basename(filepath)
    base = os.path.splitext(filename)[0]

    # =============== Logger individual por arquivo ===================
    log_name = f"{base}_clean.log"

    logger = logging.getLogger(base)
    logger.setLevel(logging.INFO)

    fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")

    fh = logging.FileHandler(log_name, encoding="utf-8")
    fh.setFormatter(fmt)
    fh.setLevel(logging.INFO)

    sh = logging.StreamHandler()
    sh.setFormatter(fmt)
    sh.setLevel(logging.INFO)

    if logger.hasHandlers():
        logger.handlers.clear()

    logger.addHandler(fh)
    logger.addHandler(sh)

    # ================================================================
    logger.info("\n====================================================")
    logger.info(f"📦 Processando arquivo: {filename}")
    logger.info(f"📍 ID inicial: {id_start}")
    logger.info("====================================================")

    df = pl.read_parquet(filepath)

    if ROW_LIMIT > 0:
        df = df.head(ROW_LIMIT)

    if TEXT_COLUMN not in df.columns:
        logger.error(f"❌ Arquivo {filename} sem coluna 'text'. Ignorando.")
        return id_start

    # ======================= CRIAR IDS ==============================
    if ADD_ID:
        new_ids = list(range(id_start, id_start + df.height))
        df = df.with_columns(pl.Series("id", new_ids))
        cols = ["id"] + [c for c in df.columns if c != "id"]
        df = df.select(cols)

        logger.info(f"🆔 ID intervalo: {new_ids[0]} → {new_ids[-1]}")

    removals = {
        "remove_patterns": [],
        "remove_lang": [],
        "remove_normalize": [],
        "remove_truncated": [],
        "remove_duplicates_sha": []
    }

    def track(stage, old, new):
        old_ids = set(old["id"])
        new_ids = set(new["id"])
        removed = sorted(list(old_ids - new_ids))
        removals[stage].extend(removed)
        logger.info(f"🗑️ {stage}: {len(removed)} removidos → {removed}")

    # ==================== 1) PATTERNS ==============================
    old = df
    df = df.with_columns(pl.col(TEXT_COLUMN).map_elements(remove_patterns_func))
    df = df.drop_nulls(subset=[TEXT_COLUMN])
    track("remove_patterns", old, df)

    # ==================== 2) Língua ================================
    old = df
    df = df.with_columns(pl.col(TEXT_COLUMN).map_elements(lambda x: x if is_portuguese(x) else None))
    df = df.drop_nulls(subset=[TEXT_COLUMN])
    track("remove_lang", old, df)

    # ==================== 3) Normalize =============================
    old = df
    df = df.with_columns(pl.col(TEXT_COLUMN).map_elements(normalize))
    df = df.drop_nulls(subset=[TEXT_COLUMN])
    track("remove_normalize", old, df)

    # ==================== 4) Truncated =============================
    old = df
    df = df.with_columns(pl.col(TEXT_COLUMN).map_elements(remove_truncated))
    df = df.drop_nulls(subset=[TEXT_COLUMN])
    track("remove_truncated", old, df)

    # ==================== 5) SHA ==================================
    if ADD_SHA:
        df = df.with_columns(pl.col(TEXT_COLUMN).map_elements(compute_sha).alias("sha"))

    # ==================== 6) Duplicados SHA ========================
    if ADD_SHA and REMOVE_DUPLICATES:
        old = df
        df = df.unique(subset=["sha"])
        track("remove_duplicates_sha", old, df)

    # ==================== 7) CATEGORIA =============================
    if ADD_CATEGORY:
        df = df.with_columns(
            pl.col(TEXT_COLUMN).map_elements(classify_text).alias("category")
        )

    df = df.sort("id")

    # ==================== Salvar FULL ==============================
    output_name = f"{base}{CLEAN_SUFFIX}"
    df.write_parquet(output_name)

    logger.info(f"💾 Salvo: {output_name}")

    # ==================== Atualizar last_id ========================
    final_last_id = df["id"].max()
    logger.info(f"🔢 Último ID deste arquivo: {final_last_id}")

    return final_last_id + 1


# ===================================================================
# =============================== MAIN ===============================
# ===================================================================

def main():

    last_id = load_last_id()
    next_id = last_id + 1

    # listar arquivos
    files = [
        f for f in os.listdir(".")
        if f.startswith(FILE_PATTERN) and f.endswith(".parquet")
    ]

    if not files:
        print("❌ Nenhum parquet encontrado.")
        return

    # ordenar numericamente
    def extract_num(fname):
        try:
            return int(fname.split("-")[1])
        except:
            return 0

    files = sorted(files, key=extract_num)

    print(f"📚 Arquivos encontrados: {files}")
    print(f"🔢 last_id carregado: {last_id}")

    for file in files:
        final_id_next = process_file(file, next_id)
        next_id = final_id_next
        save_last_id(final_id_next - 1)

    print("\n==================== FINALIZADO (v76) ====================")
    print(f"🔢 Novo last_id salvo: {next_id - 1}")


if __name__ == "__main__":
    main()