from flask import Flask, render_template, request
import imaplib
import email
import re
from datetime import datetime, timedelta
import gspread
from oauth2client.service_account import ServiceAccountCredentials
import requests  # <-- Agregamos esta para las alertas

app = Flask(__name__)

# --- FUNCIÓN DE ALERTA (BOT DE TELEGRAM) ---
def enviar_alerta_seguridad(cliente_correo, plataforma, motivo):
    token = "8650259963:AAE-x5tN2XbtlDNvQJwiJ8KXwko3qlz8YoY"  # Reemplaza con tu Token
    chat_id = "5765442173"           # Reemplaza con tu ID
    
    mensaje = (
        f"⚠️ *ALERTA CYBERSTORE*\n\n"
        f"👤 *Cliente:* {cliente_correo}\n"
        f"📺 *Plataforma:* {plataforma}\n"
        f"🚫 *Intento:* {motivo}\n"
        f"✅ *Acción:* Código Bloqueado."
    )

    url = f"https://api.telegram.org/bot{token}/sendMessage"
    try:
        requests.post(url, data={"chat_id": chat_id, "text": mensaje, "parse_mode": "Markdown"})
    except:
        pass

# --- 1. CONEXIÓN AL EXCEL DE REVENDEDORES ---
def conectar_hoja_plataforma(nombre_plataforma):
    try:
        scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"]
        creds = ServiceAccountCredentials.from_json_keyfile_name('credenciales.json', scope)
        client = gspread.authorize(creds)
        
        # Conecta a tu nuevo documento dedicado a revendedores
        spreadsheet = client.open("REVENDEDORES_STREAMING") 
        return spreadsheet.worksheet(nombre_plataforma.upper())
    except Exception as e:
        print(f"Error al conectar con la pestaña {nombre_plataforma}: {e}")
        return None

# --- 2. VALIDACIÓN (Clave Única + Estado + Rol) ---
def validar_credenciales(pass_input, plataforma):
    hoja = conectar_hoja_plataforma(plataforma)
    if not hoja:
        return False, "Error: No se encontró la base de datos.", None

    registros = hoja.get_all_records()
    
    for fila in registros:
        if str(fila.get('CLAVE_UNICA', '')).strip() == str(pass_input).strip():
            
            if str(fila.get('ESTADO', '')).strip().upper() != 'ACTIVO':
                return False, "Error: Tu usuario está inactivo. Contacta a soporte.", None
            
            # Extraemos el rol (ADMIN, PROVEEDOR, o CLIENTE)
            tipo_usuario = str(fila.get('TIPO_USUARIO', 'CLIENTE')).strip().upper()
            
            return True, f"Conexión exitosa.", tipo_usuario

    return False, "Error: Clave única incorrecta o no registrada.", None

# --- FUNCIÓN MOTOR IMAP ---
def borrar_correo_procesado(mail, email_id):
    try:
        mail.store(email_id, '+FLAGS', '\\Deleted')
        mail.expunge()
    except:
        pass

def buscar_codigo_en_email(correo_cliente, plataforma_sel, tipo_usuario):
    try:
        # --- LÓGICA DE PERMISOS POR TIPO DE USUARIO ---
        if tipo_usuario == 'ADMIN':
            PALABRAS_PROHIBIDAS = [] # El Admin puede ver TODO
            PALABRAS_PERMITIDAS = ["código", "code", "verificación", "verification", "inicio", "login", "tv", "password", "contraseña", "correo", "email", "dispositivo", "hogar"]
            
        elif tipo_usuario == 'PROVEEDOR':
            PALABRAS_PROHIBIDAS = ["cambiar correo", "email change", "actualizar correo", "cambio de email"]
            PALABRAS_PERMITIDAS = ["código", "code", "verificación", "verification", "inicio", "login", "tv", "password reset", "restablecer", "contraseña", "password", "dispositivo", "hogar", "household"]
            
        else: 
            PALABRAS_PROHIBIDAS = ["password reset", "restablecer contraseña", "cambiar correo", "email change", "cambio de email", "actualizar correo", "restablecer password", "cambiar contraseña", "cambiar password", "hogar", "household", "dispositivo"]
            PALABRAS_PERMITIDAS = ["código", "code", "verificación", "verification", "inicio", "login", "tv", "iniciar sesión", "acceso"]

        keywords = {
            "NETFLIX": "netflix", "DISNEY": "disney",
            "HBOMAX": "hbo", "PRIMEVIDEO": "amazon"
        }
        palabra_plataforma = keywords.get(plataforma_sel.upper(), "")

        # --- AQUI ESTÁ LA MAGIA: TUS DOS CUENTAS ---
        CUENTAS_BOT = [
            {'server': 'mail.micyberstore.com', 'user': 'bot@str.micyberstore.com', 'pass': 'Ku3Z~lO_hX=}G^b@'},
            {'server': 'mail.micyberstore.com', 'user': 'tubot@micyberstore.com', 'pass': '5blfqG7}f=gYX8*u'} 
        ]

        error_general = f"No se detectó un código válido y reciente (15 min) para {correo_cliente}."

        # El Bot intentará buscar en la primera cuenta, y si no hay nada, pasará a la segunda
        for credenciales in CUENTAS_BOT:
            mail = None
            try:
                mail = imaplib.IMAP4_SSL(credenciales['server'])
                mail.login(credenciales['user'], credenciales['pass'])
                mail.select("inbox")

                # 1. Filtro de Fecha: Solo correos de hoy para optimizar velocidad
                fecha_filtro = datetime.now().strftime("%d-%b-%Y")
                
                # 2. Buscamos correos dirigidos específicamente a ese correo del cliente
                criterio = f'(TO "{correo_cliente}" SINCE {fecha_filtro})'
                status, messages = mail.search(None, criterio)

                if not messages[0]:
                    continue # Si no hay correos en esta cuenta, salta a revisar la otra cuenta

                ids = messages[0].split()
                ids.reverse() # Revisar el más reciente primero

                ahora = datetime.now()

                for email_id in ids:
                    res, msg_data = mail.fetch(email_id, '(RFC822)')
                    for response_part in msg_data:
                        if isinstance(response_part, tuple):
                            msg = email.message_from_bytes(response_part[1])
                            
                            # --- VALIDACIÓN ESTRICTA DE DESTINATARIO ---
                            destinatario_real = str(msg['To']).lower()
                            if correo_cliente.lower() not in destinatario_real:
                                continue 

                            # --- FILTRO DE TIEMPO (MÁXIMO 15 MINUTOS) ---
                            fecha_correo = email.utils.parsedate_to_datetime(msg['Date'])
                            diferencia = ahora - fecha_correo.replace(tzinfo=None)
                            
                            if diferencia > timedelta(minutes=15):
                                error_general = "El código ha expirado (más de 15 minutos). Solicita uno nuevo en la App."
                                return None, error_general

                            # --- PROCESAMIENTO DE CUERPO Y ASUNTO ---
                            asunto = str(msg['Subject']).lower()
                            cuerpo = ""
                            if msg.is_multipart():
                                for part in msg.walk():
                                    if part.get_content_type() == "text/plain":
                                        cuerpo = part.get_payload(decode=True).decode(errors='ignore').lower()
                            else:
                                cuerpo = msg.get_payload(decode=True).decode(errors='ignore').lower()

                            # --- FILTRO 1: Plataforma correcta ---
                            if palabra_plataforma not in asunto and palabra_plataforma not in cuerpo:
                                continue 

                            # --- FILTRO 2: SEGURIDAD SEGÚN ROL ---
                            for prohibida in PALABRAS_PROHIBIDAS:
                                if prohibida in asunto or prohibida in cuerpo:
                                    motivo = f"Intento no autorizado ({tipo_usuario}) - Acción: {prohibida}"
                                    enviar_alerta_seguridad(correo_cliente, plataforma_sel, motivo)
                                    return None, f"⚠️ Seguridad: No tienes permisos ({tipo_usuario}) para ver códigos de esta acción."

                            # --- FILTRO 3: Intención válida ---
                            intencion_valida = any(p in asunto or p in cuerpo for p in PALABRAS_PERMITIDAS)
                            if not intencion_valida:
                                continue

                            # --- EXTRACCIÓN DEL CÓDIGO (CyberStore v4 - Ancla Estricta) ---
                            cuerpo_procesado = re.sub(r'(?<=\d)\s+(?=\d)', '', cuerpo)
                            
                            codigo = None
                            plataforma_upper = plataforma_sel.upper()

                            if plataforma_upper == "DISNEY":
                                match = re.search(r'15\s*minutos\.?\s*(\d{6})', cuerpo_procesado, re.IGNORECASE)
                                if match:
                                    codigo = match.group(1)
                                    
                            elif plataforma_upper == "NETFLIX":
                                match = re.search(r'(?:código|inicio|code).*?(\d{4})', cuerpo_procesado, re.DOTALL | re.IGNORECASE)
                                if match:
                                    codigo = match.group(1)
                                    
                            elif plataforma_upper in ["HBOMAX", "PRIMEVIDEO"]:
                                match = re.search(r'(?:código|acceso|code|verific).*?(\d{6})', cuerpo_procesado, re.DOTALL | re.IGNORECASE)
                                if match:
                                    codigo = match.group(1)
                            
                            if not codigo:
                                largos_validos = {"NETFLIX": [4], "DISNEY": [6], "HBOMAX": [6], "PRIMEVIDEO": [6]}
                                esperado = largos_validos.get(plataforma_upper, [4, 6])
                                
                                todos_los_numeros = re.finditer(r'(?<!#)\b(\d{4,8})\b', cuerpo_procesado)
                                
                                for coincidencia in todos_los_numeros:
                                    n = coincidencia.group(1)
                                    if n in ["707070", "010101", "ffffff", "000000"]:
                                        continue
                                        
                                    if len(n) in esperado:
                                        codigo = n
                                        break

                            if codigo:
                                borrar_correo_procesado(mail, email_id)
                                return codigo, None
            
            except Exception as e:
                print(f"Error al conectar con la cuenta {credenciales['user']}: {e}")
                continue # Si una cuenta falla (ej. contraseña mal), sigue con la otra
            
            finally:
                if mail:
                    try: mail.logout()
                    except: pass
                    
        # Si termina de revisar ambos correos y no encontró nada, arroja el error
        return None, error_general

    except Exception as e:
        return None, f"Error general: {str(e)}"

@app.route("/", methods=["GET", "POST"])
def index():
    codigo = None
    error = None
    if request.method == "POST":
        correo = request.form.get("correo")
        clave_unica = request.form.get("password")
        plataforma = request.form.get("plataforma")
        
        # Recibimos el tipo_usuario de la validación
        valido, mensaje_val, tipo_usuario = validar_credenciales(clave_unica, plataforma)
        
        if valido:
            # Le pasamos el tipo_usuario al buscador de correos
            res_codigo, err_mail = buscar_codigo_en_email(correo, plataforma, tipo_usuario)
            
            if res_codigo:
                codigo = res_codigo
            else:
                error = err_mail
        else:
            error = mensaje_val
            
    return render_template("index.html", codigo=codigo, error=error)

if __name__ == "__main__":
    app.run(debug=True)