"""
Procesa los JSON de sociedades en la carpeta boletines_json.
"""

import json
import logging
import pathlib
import os
import socket
import sys
from dotenv import load_dotenv

# Permitir importar `helpers` cuando se ejecuta como script suelto
# (python procesamiento/procesar_json_edictos.py)
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent.parent))
from helpers.singleton import single_instance
from helpers.db import ejecutar_sp, conectar
from helpers.buscar_cuit import buscar_cuit
from helpers.logging_setup import setup_logging, setup_logging_db

load_dotenv()
_run_id = setup_logging("json_edictos")

ID_PROCESO = int(os.getenv("ID_PROCESO_JSON_EDICTOS", 0))

def insert_edictos_queue_staging(cuit, razon_social, fecha, provincia, edicto, conn):
    try:
        ejecutar_sp(
            'insert_edictos_queue_staging',
            [cuit, razon_social, fecha, provincia, edicto],
            conn,
        )
        conn.commit()
        return True
    except Exception as e:
        logging.error(f"ERROR_STAGING | cuit={cuit} razon_social='{razon_social}': {e}")
        return False


CARPETA = pathlib.Path(__file__).resolve().parent.parent.parent / "files" / "boletines_json"

# Provincias válidas tal como se insertan en la base de datos
PROVINCIAS_VALIDAS = {
    "BUENOS AIRES",
    "CIUDAD AUTONOMA DE BUENOS AIRES",
    "CATAMARCA",
    "CHACO",
    "CHUBUT",
    "CORDOBA",
    "CORRIENTES",
    "ENTRE RIOS",
    "FORMOSA",
    "JUJUY",
    "LA PAMPA",
    "LA RIOJA",
    "MENDOZA",
    "MISIONES",
    "NEUQUEN",
    "RIO NEGRO",
    "SALTA",
    "SAN JUAN",
    "SAN LUIS",
    "SANTA CRUZ",
    "SANTA FE",
    "SANTIAGO DEL ESTERO",
    "TIERRA DEL FUEGO",
    "TUCUMAN",
    "BORA",
}

# Carpeta de provincia → nombre de provincia para la DB
FOLDER_TO_PROVINCIA = {
    "buenos_aires":        "BUENOS AIRES",
    "bora":                "BORA",
    "catamarca":           "CATAMARCA",
    "chaco":               "CHACO",
    "chubut":              "CHUBUT",
    "cordoba":             "CORDOBA",
    "corrientes":          "CORRIENTES",
    "entre_rios":          "ENTRE RIOS",
    "formosa":             "FORMOSA",
    "jujuy":               "JUJUY",
    "la_pampa":            "LA PAMPA",
    "la_rioja":            "LA RIOJA",
    "mendoza":             "MENDOZA",
    "misiones":            "MISIONES",
    "neuquen":             "NEUQUEN",
    "rio_negro":           "RIO NEGRO",
    "salta":               "SALTA",
    "san_juan":            "SAN JUAN",
    "san_luis":            "SAN LUIS",
    "santa_cruz":          "SANTA CRUZ",
    "santa_fe":            "SANTA FE",
    "santiago_del_estero": "SANTIAGO DEL ESTERO",
    "tierra_del_fuego":    "TIERRA DEL FUEGO",
    "tucuman":             "TUCUMAN",
}


def validar_provincia(provincia: str | None) -> str | None:
    if not provincia:
        return None
    normalizada = provincia.strip().upper()
    return normalizada if normalizada in PROVINCIAS_VALIDAS else None


def main():
    filtro_provincia = None
    if "--provincia" in sys.argv:
        _idx = sys.argv.index("--provincia")
        filtro_provincia = sys.argv[_idx + 1].lower()

    id_log = None
    try:
        result = ejecutar_sp('PRS_iniciar', [
            ID_PROCESO,
            socket.gethostbyname(socket.gethostname()),
            os.getpid(),
            socket.gethostname(),
            12,
            _run_id,
        ])
        if result:
            id_log = result[0].get('id_log')
            setup_logging_db(id_log)
    except Exception as e:
        logging.warning(f"PRS_iniciar falló: {e}")

    ok_count = 0
    error_count = 0
    total = 0

    logging.info("Inicio")

    try:
        with conectar() as conn:
            archivos = sorted(CARPETA.glob("*/*.json"))
            if filtro_provincia:
                archivos = [a for a in archivos if filtro_provincia in a.parent.name.lower()]
            total = len(archivos)
            if not archivos:
                logging.info("No se encontraron JSONs para procesar.")

            for archivo in archivos:
                prov_folder   = archivo.parent
                prov_nombre   = FOLDER_TO_PROVINCIA.get(prov_folder.name, prov_folder.name.upper().replace("_", " "))

                dest_procesados  = prov_folder / "procesados"
                dest_sin_edictos = prov_folder / "sin_edictos"
                dest_error       = prov_folder / "error"
                for d in [dest_procesados, dest_sin_edictos, dest_error]:
                    d.mkdir(exist_ok=True)

                try:
                    data = json.loads(archivo.read_text(encoding="utf-8"))
                except Exception as e:
                    logging.error(f"ERROR_LECTURA | {prov_folder.name}/{archivo.name}: {e}")
                    archivo.rename(dest_error / archivo.name)
                    error_count += 1
                    continue

                fecha_publicacion = data.get("fecha_publicacion")
                edictos = data.get("edictos", [])

                logging.info(f"PROCESANDO | {prov_folder.name}/{archivo.name} provincia={prov_nombre} fecha={fecha_publicacion} edictos={len(edictos)}")

                if not edictos:
                    archivo.rename(dest_sin_edictos / archivo.name)
                    logging.info(f"SIN_EDICTOS | {archivo.name} → sin_edictos/")
                    ok_count += 1
                    continue

                hubo_error = False
                for edicto in edictos:

                    
                    razon_social = edicto.get("razon_social")
                    texto_edicto = edicto.get("texto_edicto")

                    provincia_final = prov_nombre

                    cuit = buscar_cuit(razon_social, conn)

                    cuit_str = f"CUIT: {cuit}" if cuit else "sin CUIT"

                    ok = insert_edictos_queue_staging(
                        cuit=cuit,
                        razon_social=razon_social,
                        fecha=fecha_publicacion,
                        provincia=provincia_final,
                        edicto=texto_edicto,
                        conn=conn,
                    )
                    if not ok:
                        hubo_error = True

                    estado = "OK" if ok else "ERROR"
                    logging.debug(f"EDICTO_{estado} | {razon_social} {cuit_str} [{provincia_final}]")

                if hubo_error:
                    logging.error(f"ARCHIVO_ERROR | {prov_folder.name}/{archivo.name} edictos={len(edictos)} → error/")
                    archivo.rename(dest_error / archivo.name)
                    error_count += 1
                else:
                    logging.info(f"ARCHIVO_OK | {prov_folder.name}/{archivo.name} edictos={len(edictos)} → procesados/")
                    archivo.rename(dest_procesados / archivo.name)
                    ok_count += 1
    finally:
        logging.info(f"Fin. OK: {ok_count} | Error: {error_count} | Total: {total}")
        if id_log is not None:
            try:
                ejecutar_sp('PRS_finalizar', [id_log, None, total, ok_count, error_count])
            except Exception as e:
                logging.warning(f"PRS_finalizar falló: {e}")


if __name__ == "__main__":
    with single_instance("procesar_json_edictos"):
        main()