from busqueda_cuit.helpers import purgar_espacios, purgar_nombre, purgar_cuit
from busqueda_cuit.provincias import PROVINCIAS_CON_NUMERO
import re

def ejecutar_busqueda(cursor, cuit=None, razon_social=None, cod_provincia=None):
    try:
        cursor.execute(
            'EXEC [dbo].[unico_buscador_padron] ?, ?, ?, ?, ?, ?, ?, ?, ?',
            None, cuit, razon_social, None, None, None, cod_provincia, None, None
        )
        return cursor.fetchall()
    except Exception as e:
        print("Error al ejecutar el stored procedure:", e)
        return None
    
def ejecutar_busqueda_cuit(cursor, cuit=None, cod_provincia=None):
    try:
        cursor.execute(
            'EXEC [dbo].[buscador_paises_padron] ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?',
            'masivos', None, cuit, 'AR', cod_provincia, None, None, None, None, None, None, None
        )
        return cursor.fetchall()
    except Exception as e:
        print("Error al ejecutar el stored procedure:", e)
        return None

def compactar_siglas(texto):
    texto = re.sub(r'\bS[\s\.]*A[\s\.]*S\b', 'SAS', texto, flags=re.IGNORECASE)
    texto = re.sub(r'\bS[\s\.]*R[\s\.]*L\b', 'SRL', texto, flags=re.IGNORECASE)
    texto = re.sub(r'\bS[\s\.]*A\b', 'SA', texto, flags=re.IGNORECASE)
    return texto

def ejecutar_busqueda_rs(cursor, razon_social=None, cod_provincia=None):
    try:
        razon_social = compactar_siglas(razon_social)

        cursor.execute(
            'EXEC [dbo].[buscador_paises_padron] ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?',
            'masivos', None, razon_social, 'AR', cod_provincia, None, None, None, None, None, None, None
        )
        return cursor.fetchall()
    except Exception as e:
        print("Error al ejecutar el stored procedure:", e)
        return None

def ejecutar_busqueda_prov(cursor, razon_social=None, cod_provincia=None):
    try:
        cursor.execute(
            'EXEC [dbo].[buscador_paises_padron] ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?',
            'buscador', None, razon_social, 'AR', cod_provincia, None, None, None, None, None, None, None
        )
        return cursor.fetchall()
    except Exception as e:
        print("Error al ejecutar el stored procedure:", e)
        return None

def Regla1(cuit, cursor):
    if cuit and cuit.lower() != 'null':
        cuit = purgar_cuit(cuit)
        print("Buscar por CUIT")
        resultados = ejecutar_busqueda_cuit(cursor, cuit=cuit)
        if len(resultados) == 1:
            print("Resultados CUIT genera sugerencia:", cuit)
            return cuit
        else:
            print("No se encontraron resultados para el CUIT o hay más de un resultado.")
            return None
    else:
        return None

def Regla2bkp(cuit, razon_social, provincia, cursor):
    if (not cuit or str(cuit).lower() == 'null') and razon_social and razon_social.lower() != 'null':
        # Buscar por razón social
        resultados = ejecutar_busqueda_rs(cursor, razon_social=razon_social) or []
        resultados = [(r[3], r[4]) for r in resultados]

        if len(resultados) == 1:
            cuit_result = resultados[0][0]
            print("RS única genera sugerencia:", cuit_result)
            return cuit_result

        if len(resultados) == 0:
            print("No se encontraron resultados.")
            return None

        # Coincidencias exactas
        coincidencias_exactas = [
            r for r in resultados if purgar_nombre(purgar_espacios(razon_social)) == purgar_nombre(purgar_espacios(r[1]))
        ]
        if len(coincidencias_exactas) == 1:
            cuit_result = coincidencias_exactas[0][0]
            print("Coincidencia exacta única entre múltiples resultados, sugerido:", cuit_result)
            return cuit_result

        # Filtrado por provincia
        if provincia:
            cod_prov = PROVINCIAS_CON_NUMERO.get(provincia.strip().upper())
            if cod_prov is None:
                print(f"Provincia '{provincia}' no reconocida. Multiples resultados.")
                return resultados

            resultados = ejecutar_busqueda_prov(cursor, razon_social=razon_social, cod_provincia=cod_prov) or []
            resultados = [(r[3], r[4]) for r in resultados]

            if len(resultados) == 1:
                cuit_result = resultados[0][0]
                print("Resultado RS por provincia sugiere:", cuit_result)
                return cuit_result
            else:
                print("Multiples resultados tras filtrar por provincia.")
                return resultados
        else:
            print("Multiples resultados sin filtrar por provincia.")
            return resultados
    else:
        print("Sin razón social para buscar.")
        return None


def Regla2(cuit, razon_social, provincia, cursor):
    if (not cuit or str(cuit).lower() == 'null') and razon_social and razon_social.lower() != 'null':
        razon_social_limpia = limpiar_razon_social(razon_social)

        try:
            resultados = ejecutar_busqueda_rs(cursor, razon_social=razon_social_limpia) or []
        except Exception as e:
            print(f"Error al ejecutar_busqueda_rs: {e}")
            return None

        if not resultados:
            print("No se encontraron resultados.")
            return None

        try:
            resultados = [(r[3], r[4]) for r in resultados]
        except Exception:
            print("Error: estructura inesperada en resultados.")
            return None

        if len(resultados) == 1:
            cuit_result = resultados[0][0]
            print("RS única genera sugerencia:", cuit_result)
            return cuit_result

        coincidencias_exactas = [
            r for r in resultados
            if purgar_nombre(purgar_espacios(razon_social)) == purgar_nombre(purgar_espacios(r[1]))
        ]
        if len(coincidencias_exactas) == 1:
            cuit_result = coincidencias_exactas[0][0]
            print("Coincidencia exacta única entre múltiples resultados, sugerido:", cuit_result)
            return cuit_result

        if provincia:
            cod_prov = PROVINCIAS_CON_NUMERO.get(provincia.strip().upper())
            if cod_prov is None:
                print(f"Provincia '{provincia}' no reconocida. Multiples resultados.")
                return resultados

            try:
                resultados = ejecutar_busqueda_prov(cursor, razon_social=razon_social_limpia, cod_provincia=cod_prov) or []
            except Exception as e:
                print(f"Error al ejecutar_busqueda_prov: {e}")
                return None

            if not resultados:
                print("Sin resultados para provincia especificada.")
                return None

            try:
                resultados = [(r[3], r[4]) for r in resultados]
            except Exception:
                print("Error: estructura inesperada en resultados (provincia).")
                return None

            if len(resultados) == 1:
                cuit_result = resultados[0][0]
                print("Resultado RS por provincia sugiere:", cuit_result)
                return cuit_result
            else:
                print("Multiples resultados tras filtrar por provincia.")
                return resultados
        else:
            print("Multiples resultados sin filtrar por provincia.")
            return resultados
    else:
        print("Sin razón social para buscar.")
        return None
    
def limpiar_razon_social(texto):
   
    if not texto:
        return ""

    # Normaliza espacios y mayusculas
    texto = re.sub(r'\s+', ' ', texto.strip().upper())

    texto = re.sub(r'\bS[\s\.]*A[\s\.]*S\b', 'SAS', texto)
    texto = re.sub(r'\bS[\s\.]*R[\s\.]*L\b', 'SRL', texto)
    texto = re.sub(r'\bS[\s\.]*A\b', 'SA', texto)

    palabras = texto.split()

    palabras = [p for p in palabras if len(p) > 1 and p.isalnum()]

    palabras = palabras[:15]

    return " ".join(palabras)