#!/usr/bin/env python3
"""
Extrair cookies do Google Flow da sessão Chrome ativa
"""
import asyncio
from playwright.async_api import async_playwright
import json
import sqlite3
import os
import base64
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import keyring

async def extract_cookies_from_running_chrome():
    """Conecta no Chrome rodando e extrai cookies"""
    async with async_playwright() as p:
        # Conectar no Chrome já rodando via debug port
        try:
            browser = await p.chromium.connect_over_cdp("http://localhost:9222")
            print("✅ Conectado no Chrome rodando")
            
            contexts = browser.contexts
            if not contexts:
                print("❌ Nenhum contexto encontrado")
                return None
                
            context = contexts[0]
            pages = context.pages
            
            flow_page = None
            for page in pages:
                url = page.url
                print(f"📄 Página encontrada: {url}")
                if 'labs.google' in url:
                    flow_page = page
                    break
            
            if not flow_page:
                print("❌ Página do Flow Labs não encontrada")
                return None
                
            print(f"🎯 Flow Labs encontrado: {flow_page.url}")
            
            # Extrair cookies
            cookies = await context.cookies()
            
            # Salvar cookies
            with open('google_flow_cookies_logged.json', 'w') as f:
                json.dump(cookies, f, indent=2)
            
            # Procurar tokens específicos
            session_tokens = []
            csrf_tokens = []
            auth_tokens = []
            
            for cookie in cookies:
                name = cookie['name'].lower()
                domain = cookie.get('domain', '')
                
                if 'labs.google' in domain or 'google.com' in domain:
                    if 'session' in name or 'auth' in name:
                        session_tokens.append(cookie)
                        print(f"🍪 Session: {cookie['name']} = {cookie['value'][:50]}...")
                    elif 'csrf' in name or 'xsrf' in name:
                        csrf_tokens.append(cookie)
                        print(f"🛡️ CSRF: {cookie['name']} = {cookie['value'][:50]}...")
                    elif 'token' in name:
                        auth_tokens.append(cookie)
                        print(f"🔑 Token: {cookie['name']} = {cookie['value'][:50]}...")
            
            await browser.close()
            
            return {
                'session_tokens': session_tokens,
                'csrf_tokens': csrf_tokens,
                'auth_tokens': auth_tokens,
                'all_cookies': cookies
            }
            
        except Exception as e:
            print(f"❌ Erro conectando Chrome: {e}")
            return None

def extract_cookies_from_sqlite():
    """Extrair cookies do banco SQLite do Chrome"""
    cookies_db = "/tmp/chrome-flow-manual/Default/Cookies"
    
    if not os.path.exists(cookies_db):
        print(f"❌ Banco de cookies não encontrado: {cookies_db}")
        return None
    
    try:
        # Copiar banco para evitar lock
        os.system(f"cp '{cookies_db}' /tmp/cookies_temp.db")
        
        conn = sqlite3.connect('/tmp/cookies_temp.db')
        cursor = conn.cursor()
        
        # Buscar cookies do Google Flow
        cursor.execute("""
            SELECT name, value, host_key, path, expires_utc, is_secure, is_httponly
            FROM cookies 
            WHERE host_key LIKE '%google%' OR host_key LIKE '%labs.google%'
        """)
        
        cookies = cursor.fetchall()
        conn.close()
        
        flow_cookies = []
        for cookie in cookies:
            name, value, host, path, expires, secure, httponly = cookie
            
            flow_cookies.append({
                'name': name,
                'value': value,
                'domain': host,
                'path': path,
                'expires': expires,
                'secure': bool(secure),
                'httpOnly': bool(httponly)
            })
            
            if any(x in name.lower() for x in ['session', 'auth', 'csrf', 'token']):
                print(f"🍪 {name} = {value[:50]}...")
        
        # Salvar cookies extraídos
        with open('google_flow_cookies_sqlite.json', 'w') as f:
            json.dump(flow_cookies, f, indent=2)
        
        return flow_cookies
        
    except Exception as e:
        print(f"❌ Erro extraindo do SQLite: {e}")
        return None

async def main():
    print("🍪 Extraindo cookies do Google Flow...")
    
    # Método 1: Chrome rodando via CDP
    print("\n🔄 Método 1: Chrome CDP...")
    cookies_cdp = await extract_cookies_from_running_chrome()
    
    # Método 2: SQLite direto
    print("\n🔄 Método 2: SQLite...")
    cookies_sqlite = extract_cookies_from_sqlite()
    
    if cookies_cdp:
        print(f"\n✅ Extraídos {len(cookies_cdp['all_cookies'])} cookies via CDP")
        
        # Atualizar banco VisionaryFX com novos tokens
        session_token = None
        csrf_token = None
        
        for cookie in cookies_cdp['session_tokens']:
            if 'session' in cookie['name'].lower():
                session_token = cookie['value']
                break
                
        for cookie in cookies_cdp['csrf_tokens']:
            if 'csrf' in cookie['name'].lower():
                csrf_token = cookie['value']
                break
        
        if session_token:
            print(f"\n🎯 SESSION TOKEN: {session_token[:100]}...")
        if csrf_token:
            print(f"\n🛡️ CSRF TOKEN: {csrf_token[:100]}...")
            
        return session_token, csrf_token
    
    elif cookies_sqlite:
        print(f"\n✅ Extraídos {len(cookies_sqlite)} cookies via SQLite")
    
    else:
        print("\n❌ Falhou em extrair cookies")
        
    return None, None

if __name__ == "__main__":
    session, csrf = asyncio.run(main())