#!/usr/bin/env python3
"""
Flask Server para Google Scraper UI
Fornece API REST para o frontend HTML
"""

from flask import Flask, jsonify, request, send_from_directory
from flask_cors import CORS
import sys
import os
from pathlib import Path

# Carregar variáveis do .env
def load_env():
    """Carrega variáveis de ambiente do arquivo .env"""
    env_path = Path(__file__).parent / '.env'
    if env_path.exists():
        with open(env_path) as f:
            for line in f:
                line = line.strip()
                if line and not line.startswith('#') and '=' in line:
                    key, value = line.split('=', 1)
                    os.environ[key.strip()] = value.strip()
        print(f"✅ Variáveis carregadas de {env_path}")
    else:
        print(f"⚠️  Arquivo .env não encontrado em {env_path}")

load_env()

# Importar o scraper
sys.path.append(os.path.dirname(__file__))

# Versão simplificada do scraper para o servidor
import requests
from bs4 import BeautifulSoup
from urllib.parse import quote_plus
from datetime import datetime

app = Flask(__name__)
CORS(app)  # Permitir requisições cross-origin

class GoogleScraperAPI:
    """API do Google Scraper para o servidor"""

    def __init__(self, api_provider='native', api_key=None):
        self.api_provider = api_provider
        self.api_key = api_key or os.getenv(f'{api_provider.upper()}_API_KEY')

    def scrape_native(self, query, num_results=10):
        """Scraping direto do Google"""

        headers = {
            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8',
        }

        url = f'https://www.google.com/search?q={quote_plus(query)}&num={num_results}'

        try:
            response = requests.get(url, headers=headers, timeout=10)
            response.raise_for_status()
            soup = BeautifulSoup(response.text, 'html.parser')

            results = []
            search_results = soup.find_all('div', class_='g')

            for idx, result in enumerate(search_results[:num_results], 1):
                try:
                    title_elem = result.find('h3')
                    title = title_elem.get_text() if title_elem else 'N/A'

                    link_elem = result.find('a')
                    link = link_elem.get('href') if link_elem else 'N/A'

                    desc_elem = result.find('div', class_=['VwiC3b', 'yXK7lf'])
                    description = desc_elem.get_text() if desc_elem else 'N/A'

                    results.append({
                        'position': idx,
                        'title': title,
                        'link': link,
                        'description': description
                    })
                except:
                    continue

            return results

        except Exception as e:
            raise Exception(f"Erro no scraping: {str(e)}")

    def scrape_serpapi(self, query, num_results=10):
        """SerpAPI integration"""

        if not self.api_key:
            raise Exception("SerpAPI key não configurada")

        url = "https://serpapi.com/search"
        params = {
            'q': query,
            'api_key': self.api_key,
            'num': num_results,
            'gl': 'br',
            'hl': 'pt',
            'engine': 'google'
        }

        try:
            response = requests.get(url, params=params, timeout=30)
            response.raise_for_status()
            data = response.json()

            results = []
            organic_results = data.get('organic_results', [])

            for idx, item in enumerate(organic_results[:num_results], 1):
                results.append({
                    'position': idx,
                    'title': item.get('title', 'N/A'),
                    'link': item.get('link', 'N/A'),
                    'description': item.get('snippet', 'N/A'),
                    'displayed_link': item.get('displayed_link', 'N/A')
                })

            return results

        except Exception as e:
            raise Exception(f"Erro SerpAPI: {str(e)}")

    def search(self, query, num_results=10):
        """Método principal de busca"""

        if self.api_provider == 'native':
            return self.scrape_native(query, num_results)
        elif self.api_provider == 'serpapi':
            return self.scrape_serpapi(query, num_results)
        else:
            # Para outros provedores, retornar erro explicativo
            raise Exception(f"Provedor '{self.api_provider}' requer configuração de API key")


# ========== ROUTES ==========

@app.route('/')
def index():
    """Servir a página HTML"""
    return send_from_directory('.', 'google-scraper-ui.html')

@app.route('/analyzer')
def analyzer():
    """Servir a página de análise de dados"""
    return send_from_directory('.', 'scraper-analyzer.html')

@app.route('/api/search', methods=['POST'])
def api_search():
    """
    Endpoint de busca

    POST /api/search
    Body: {
        "query": "machine learning",
        "num_results": 10,
        "provider": "native"
    }
    """

    try:
        data = request.get_json()

        query = data.get('query', '').strip()
        num_results = int(data.get('num_results', 10))
        provider = data.get('provider', 'native')

        if not query:
            return jsonify({
                'success': False,
                'error': 'Query não pode estar vazia'
            }), 400

        # Criar scraper
        scraper = GoogleScraperAPI(api_provider=provider)

        # Buscar
        start_time = datetime.now()
        results = scraper.search(query, num_results)
        end_time = datetime.now()

        search_time_ms = int((end_time - start_time).total_seconds() * 1000)

        return jsonify({
            'success': True,
            'data': {
                'query': query,
                'provider': provider,
                'timestamp': datetime.now().isoformat(),
                'search_time_ms': search_time_ms,
                'total_results': len(results),
                'results': results
            }
        })

    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/providers', methods=['GET'])
def api_providers():
    """Listar provedores disponíveis"""

    providers = [
        {
            'id': 'native',
            'name': 'Native Scraping',
            'description': 'Scraping direto do Google',
            'price': 'Grátis',
            'requires_key': False,
            'available': True
        },
        {
            'id': 'serpapi',
            'name': 'SerpAPI',
            'description': 'API popular para SERP',
            'price': '$0.005/consulta',
            'requires_key': True,
            'available': bool(os.getenv('SERPAPI_API_KEY'))
        },
        {
            'id': 'dataforseo',
            'name': 'DataForSEO',
            'description': 'API profissional para SEO',
            'price': '$0.003/consulta',
            'requires_key': True,
            'available': bool(os.getenv('DATAFORSEO_API_KEY'))
        },
        {
            'id': 'scaleserp',
            'name': 'ScaleSERP',
            'description': 'API rápida e escalável',
            'price': '$0.002/consulta',
            'requires_key': True,
            'available': bool(os.getenv('SCALESERP_API_KEY'))
        },
        {
            'id': 'brightdata',
            'name': 'Bright Data',
            'description': 'Solução enterprise',
            'price': 'Custom',
            'requires_key': True,
            'available': bool(os.getenv('BRIGHTDATA_API_KEY'))
        }
    ]

    return jsonify({
        'success': True,
        'providers': providers
    })

@app.route('/api/health', methods=['GET'])
def health_check():
    """Health check endpoint"""
    return jsonify({
        'success': True,
        'status': 'online',
        'timestamp': datetime.now().isoformat()
    })


if __name__ == '__main__':
    print("=" * 80)
    print("🚀 GOOGLE SCRAPER SERVER")
    print("=" * 80)
    print(f"\n✅ Servidor iniciado em: http://localhost:8888")
    print(f"📡 Interface UI: http://localhost:8888/")
    print(f"🔌 API Endpoint: http://localhost:8888/api/search")
    print(f"\n💡 Acesso via Tailscale: http://100.75.88.8:8888/")

    # Status das APIs
    print("\n🔑 Status das API Keys:")
    print(f"  • Native Scraping: ✅ Sempre disponível (grátis)")

    serpapi_key = os.getenv('SERPAPI_API_KEY')
    if serpapi_key:
        print(f"  • SerpAPI: ✅ Configurada ({serpapi_key[:20]}...)")
    else:
        print(f"  • SerpAPI: ❌ Não configurada")

    dataforseo_key = os.getenv('DATAFORSEO_API_KEY')
    if dataforseo_key:
        print(f"  • DataForSEO: ✅ Configurada")
    else:
        print(f"  • DataForSEO: ❌ Não configurada")

    scaleserp_key = os.getenv('SCALESERP_API_KEY')
    if scaleserp_key:
        print(f"  • ScaleSERP: ✅ Configurada")
    else:
        print(f"  • ScaleSERP: ❌ Não configurada")

    brightdata_key = os.getenv('BRIGHTDATA_API_KEY')
    if brightdata_key:
        print(f"  • Bright Data: ✅ Configurada")
    else:
        print(f"  • Bright Data: ❌ Não configurada")

    print("\nPressione Ctrl+C para parar\n")

    app.run(host='0.0.0.0', port=8888, debug=True)