import base64
import urllib.request
import urllib.error
import json
import time
import os
import mysql.connector
from concurrent.futures import ThreadPoolExecutor, as_completed

PROGRESS_FILE = 'c:/fuentes/proyectos delphi/GESTION DOCUMENTAL/RAUL_ASENCIO/revision_progreso.json'

# 1. Leer configuración de gestiondoc.ini
with open('c:/fuentes/proyectos delphi/GESTION DOCUMENTAL/RAUL_ASENCIO/gestiondoc.ini', 'r', encoding='utf-8') as f:
    text = f.read().strip()
raw = base64.b64decode(text[7:])
decrypted = bytes([b ^ 127 for b in raw]).decode('utf-8', errors='ignore')
config = {}
for line in decrypted.splitlines():
    if '=' in line:
        k, v = line.split('=', 1)
        config[k.strip()] = v.strip()

api_key = config.get('ApiKey')
model = config.get('IAModelo', 'gemini-3.7-flash')
url = f'https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={api_key}'

# 2. Conectar a base de datos y cargar empresas
conn = mysql.connector.connect(host='85.215.144.168', user='asesoft', password='Pantera1', database='pastelerias')
cursor = conn.cursor(dictionary=True)

cursor.execute('SELECT id, nombre, cif_nif FROM ge_empresas')
empresas_db = cursor.fetchall()
cif_to_empresa = {}
for emp in empresas_db:
    cif_clean = emp['cif_nif'].upper().replace('-', '').replace(' ', '').replace('.', '')
    cif_to_empresa[cif_clean] = emp

print("=== EMPRESAS REGISTRADAS EN GE_EMPRESAS ===")
for cif, emp in cif_to_empresa.items():
    print(f"ID {emp['id']}: {emp['nombre']} (CIF: {cif})")

# 3. Cargar todos los documentos de compra asociados a albaranes o facturas
cursor.execute('''
    SELECT d.id AS doc_id, d.id_empresa AS doc_empresa, 
           d.id_albaran_proveedor, d.id_factura_proveedor, 
           COALESCE(a.documento, f.documento) AS num_doc,
           COALESCE(a.idempresa, f.idempresa) AS doc_compra_empresa,
           COALESCE(p_a.nombre, p_f.nombre) AS nombre_prov,
           COALESCE(p_a.nif, p_f.nif) AS cif_prov,
           d.nombre_archivo, d.archivo
    FROM ge_documentos d
    LEFT JOIN ge_prov_albaranes a ON d.id_albaran_proveedor = a.id
    LEFT JOIN ge_proveedores p_a ON a.idproveedor = p_a.id
    LEFT JOIN ge_prov_facturas f ON d.id_factura_proveedor = f.id
    LEFT JOIN ge_proveedores p_f ON f.idproveedor = p_f.id
    WHERE d.id_albaran_proveedor IS NOT NULL OR d.id_factura_proveedor IS NOT NULL
    ORDER BY d.id ASC
''')
all_docs = cursor.fetchall()
conn.close()

print(f"\nTotal documentos de compra con archivo gráfico encontrados: {len(all_docs)}")

# Cargar progreso previo si existe
progress = {}
if os.path.exists(PROGRESS_FILE):
    try:
        with open(PROGRESS_FILE, 'r', encoding='utf-8') as pf:
            progress = json.load(pf)
        print(f"Progreso previo cargado: {len(progress)} documentos ya analizados.")
    except Exception as e:
        print(f"No se pudo cargar progreso previo: {e}")

prompt = """Analiza este documento de compra (factura o albarán de compra).
Tu objetivo es identificar a qué empresa de nuestro grupo va destinado (es decir, el RECEPTOR / CLIENTE / COMPRADOR, NUNCA el proveedor que emite el documento).

Nuestras empresas compradoras posibles son:
- F23839327: RAUL ASENCIO COOP.V. (ID 1)
- B19856855: RAUL ASENCIO PASTELERIAS S.L. (ID 2)
- B19897628: PASTELERIA LA TERE S.L.E (ID 3)
- F55476741: AYN CONSULTING COOP. V. (ID 4)
- B19897610: ALHARRUBA S.L. (ID 5)

Revisa detenidamente los datos fiscales del cliente/destinatario/facturado a.
Devuelve EXCLUSIVAMENTE un objeto JSON válido con los siguientes campos:
{
  "cif_receptor": "CIF o NIF del comprador/destinatario (sin espacios ni guiones)",
  "nombre_receptor": "Razón social o nombre comercial del comprador/destinatario",
  "id_empresa": 1, 2, 3, 4, o 5 según corresponda (o 0 si no pertenece a ninguna de estas empresas o no aparece)",
  "motivo": "Breve explicación de dónde se encontró el CIF o nombre"
}"""

def analyze_doc(doc):
    doc_id_str = str(doc['doc_id'])
    if doc_id_str in progress and progress[doc_id_str].get('id_detectado') is not None:
        return progress[doc_id_str]

    archivo_bytes = doc['archivo']
    if not archivo_bytes:
        return {'doc_id': doc['doc_id'], 'error': 'Sin archivo binario'}

    req_body = {
        'contents': [{
            'parts': [
                {'text': prompt},
                {'inline_data': {'mime_type': 'application/pdf', 'data': base64.b64encode(archivo_bytes).decode('ascii')}}
            ]
        }]
    }

    max_retries = 3
    for attempt in range(max_retries):
        try:
            req = urllib.request.Request(url, data=json.dumps(req_body).encode('utf-8'), headers={'Content-Type': 'application/json'})
            with urllib.request.urlopen(req, timeout=45) as resp:
                res = json.loads(resp.read().decode('utf-8'))
                text_out = res['candidates'][0]['content']['parts'][0]['text'].strip()
                text_out = text_out.replace('```json', '').replace('```', '').strip()
                data = json.loads(text_out)
                
                # Normalizar CIF detectado
                cif_det = (data.get('cif_receptor') or '').upper().replace('-', '').replace(' ', '').replace('.', '')
                id_det = data.get('id_empresa')
                
                # Validar cruzando con nuestro diccionario de empresas
                if cif_det in cif_to_empresa:
                    id_det = cif_to_empresa[cif_det]['id']
                elif id_det not in [1, 2, 3, 4, 5]:
                    # Buscar por texto si no vino el CIF limpio
                    nom_det = (data.get('nombre_receptor') or '').upper()
                    if 'COOP' in nom_det and 'ASENCIO' in nom_det:
                        id_det = 1
                    elif 'PASTELERIAS' in nom_det or 'PASTELERÍA' in nom_det:
                        id_det = 2
                    elif 'TERE' in nom_det:
                        id_det = 3
                    elif 'AYN' in nom_det:
                        id_det = 4
                    elif 'ALHARRUBA' in nom_det:
                        id_det = 5
                    else:
                        id_det = 0

                result = {
                    'doc_id': doc['doc_id'],
                    'tipo': 'ALBARAN' if doc['id_albaran_proveedor'] else 'FACTURA',
                    'id_albaran': doc['id_albaran_proveedor'],
                    'id_factura': doc['id_factura_proveedor'],
                    'num_doc': doc['num_doc'],
                    'prov': doc['nombre_prov'],
                    'empresa_actual': doc['doc_compra_empresa'],
                    'cif_detectado': cif_det,
                    'nombre_detectado': data.get('nombre_receptor'),
                    'id_detectado': id_det,
                    'motivo': data.get('motivo', '')
                }
                return result

        except urllib.error.HTTPError as e:
            if e.code == 429:
                time.sleep(3 * (attempt + 1))
            else:
                if attempt == max_retries - 1:
                    return {'doc_id': doc['doc_id'], 'error': f"HTTP {e.code}: {e.reason}"}
                time.sleep(2)
        except Exception as e:
            if attempt == max_retries - 1:
                return {'doc_id': doc['doc_id'], 'error': str(e)}
            time.sleep(2)

print("\nIniciando análisis concurrente de documentos con IA...")
processed_count = 0
reassign_count = 0
ok_count = 0
error_count = 0

# Usaremos ThreadPoolExecutor con 6 workers
with ThreadPoolExecutor(max_workers=6) as executor:
    futures = {executor.submit(analyze_doc, d): d for d in all_docs}
    for f in as_completed(futures):
        res = f.result()
        processed_count += 1
        doc_id = res['doc_id']
        progress[str(doc_id)] = res

        if 'error' in res:
            error_count += 1
            print(f"[{processed_count}/{len(all_docs)}] Doc {doc_id} ERROR: {res['error']}")
        else:
            emp_act = res['empresa_actual']
            emp_det = res['id_detectado']
            if emp_det and emp_det != 0 and emp_det != emp_act:
                reassign_count += 1
                diff_tag = f" --> *** REASIGNAR: Emp {emp_act} -> Emp {emp_det} ***"
            elif emp_det == emp_act:
                ok_count += 1
                diff_tag = f" (OK Emp {emp_act})"
            else:
                diff_tag = f" (Empresa {emp_det} no identificada o ajena)"
            
            print(f"[{processed_count}/{len(all_docs)}] Doc {doc_id} {res['tipo']} {res['num_doc']} | Prov: {res['prov']} | CIF: {res['cif_detectado']}{diff_tag}")

        # Guardar progreso periódicamente cada 10 docs
        if processed_count % 10 == 0 or processed_count == len(all_docs):
            with open(PROGRESS_FILE, 'w', encoding='utf-8') as pf:
                json.dump(progress, pf, indent=2, ensure_ascii=False)

print("\n" + "="*60)
print(f"ANÁLISIS COMPLETADO:")
print(f"Total procesados: {processed_count}")
print(f"Empresas coincidentes ya correctas: {ok_count}")
print(f"Documentos a reasignar: {reassign_count}")
print(f"Errores: {error_count}")
print("="*60)
