#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Script de teste para validar instalação do REXMULTITRADE
Executa testes básicos antes de rodar o robô em produção
"""

import sys
import os
import json
import urllib.request
import urllib.error
import socket
from datetime import datetime

def teste_python():
    """Verifica versão do Python"""
    print("[TEST] Verificando Python...")
    versao = sys.version_info
    if versao.major >= 3 and versao.minor >= 8:
        print(f"✓ Python {versao.major}.{versao.minor}.{versao.micro} OK")
        return True
    else:
        print(f"✗ Python {versao.major}.{versao.minor} - Requerido 3.8+")
        return False

def teste_arquivos():
    """Verifica se arquivos essenciais existem"""
    print("\n[TEST] Verificando arquivos...")
    
    arquivos = [
        'rexmultitrade.py',
        'configuracoes.json',
        'estado_robos.json',
        'api.php',
        'rexmultitrade_dashboard.php'
    ]
    
    todos_ok = True
    for arquivo in arquivos:
        caminho = os.path.join(os.path.dirname(__file__), arquivo)
        if os.path.exists(caminho):
            tamanho = os.path.getsize(caminho)
            print(f"✓ {arquivo} ({tamanho} bytes)")
        else:
            print(f"✗ {arquivo} NÃO ENCONTRADO")
            todos_ok = False
    
    return todos_ok

def teste_configuracao():
    """Valida arquivo de configuração"""
    print("\n[TEST] Validando configuração...")
    
    try:
        config_file = os.path.join(os.path.dirname(__file__), 'configuracoes.json')
        with open(config_file) as f:
            config = json.load(f)
        
        # Verificar campos obrigatórios
        campos = ['binance_api_key', 'binance_secret_key', 'moedas', 'indicadores']
        for campo in campos:
            if campo not in config:
                print(f"✗ Campo obrigatório faltando: {campo}")
                return False
        
        # Verificar credenciais
        if config['binance_api_key'] == 'COLE_SUA_API_KEY_AQUI':
            print("⚠ API Key não configurada - CONFIGURE ANTES DE RODAR")
            return False
        
        if config['binance_secret_key'] == 'COLE_SUA_SECRET_KEY_AQUI':
            print("⚠ Secret Key não configurada - CONFIGURE ANTES DE RODAR")
            return False
        
        # Verificar moedas
        if not config['moedas']:
            print("✗ Nenhuma moeda configurada")
            return False
        
        print(f"✓ Configuração válida ({len(config['moedas'])} moedas)")
        for moeda in config['moedas']:
            print(f"  - {moeda['par']}: ${moeda['capital']}")
        
        return True
        
    except Exception as e:
        print(f"✗ Erro ao validar configuração: {e}")
        return False

def teste_conectividade():
    """Testa conexão com Binance"""
    print("\n[TEST] Testando conectividade...")
    
    try:
        req = urllib.request.Request('https://api.binance.com/api/v3/ping', method='GET')
        with urllib.request.urlopen(req, timeout=5) as response:
            if response.status == 200:
                print("✓ Conexão com Binance OK")
                return True
    except Exception as e:
        print(f"✗ Erro ao conectar Binance: {e}")
        return False

def teste_api_php():
    """Testa disponibilidade da API PHP"""
    print("\n[TEST] Testando API PHP...")
    
    try:
        # Tentar acessar a API
        url = 'http://localhost/projetos/rexmultitrade/api.php?acao=obter_status'
        req = urllib.request.Request(url, method='GET')
        
        with urllib.request.urlopen(req, timeout=5) as response:
            resultado = response.read().decode()
            if 'sucesso' in resultado or 'estado' in resultado:
                print("✓ API PHP respondendo")
                return True
    except Exception as e:
        print(f"⚠ API PHP não disponível (ok se XAMPP está off): {str(e)[:50]}")
        return False

def teste_sqlite():
    """Verifica suporte SQLite"""
    print("\n[TEST] Verificando SQLite...")
    
    try:
        import sqlite3
        # Não vamos importar PDO (é PHP), mas verificamos com sqlite3 do Python
        conn = sqlite3.connect(':memory:')
        cursor = conn.cursor()
        cursor.execute('SELECT sqlite_version()')
        versao = cursor.fetchone()[0]
        print(f"✓ SQLite3 {versao} disponível")
        conn.close()
        return True
    except Exception as e:
        print(f"✗ Erro com SQLite: {e}")
        return False

def teste_internet():
    """Testa conexão geral com internet"""
    print("\n[TEST] Testando internet...")
    
    try:
        # Google DNS
        socket.create_connection(('8.8.8.8', 53), timeout=3)
        print("✓ Conexão com internet OK")
        return True
    except Exception:
        # Tentar outro método
        try:
            req = urllib.request.Request('https://www.google.com', method='HEAD')
            with urllib.request.urlopen(req, timeout=3):
                print("✓ Conexão com internet OK")
                return True
        except:
            print("✗ Sem conexão com internet")
            return False

def teste_permissoes():
    """Verifica permissões de diretórios"""
    print("\n[TEST] Verificando permissões...")
    
    diretórios = [
        ('logs', 'w'),
        ('.', 'w')
    ]
    
    todos_ok = True
    for diretorio, tipo in diretórios:
        caminho = os.path.join(os.path.dirname(__file__), diretorio)
        try:
            if tipo == 'w':
                # Tentar criar arquivo de teste
                teste_file = os.path.join(caminho, '.test_write')
                with open(teste_file, 'w') as f:
                    f.write('test')
                os.remove(teste_file)
                print(f"✓ Permissão de escrita em {diretorio}")
            elif tipo == 'r':
                # Tentar ler
                os.listdir(caminho)
                print(f"✓ Permissão de leitura em {diretorio}")
        except Exception as e:
            print(f"✗ Erro de permissão em {diretorio}: {e}")
            todos_ok = False
    
    return todos_ok

def main():
    """Executa todos os testes"""
    print("=" * 80)
    print("🔍 REXMULTITRADE - Teste de Instalação")
    print(f"Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print("=" * 80)
    
    testes = [
        ("Python", teste_python),
        ("Arquivos", teste_arquivos),
        ("Permissões", teste_permissoes),
        ("SQLite", teste_sqlite),
        ("Internet", teste_internet),
        ("Conectividade Binance", teste_conectividade),
        ("Configuração", teste_configuracao),
        ("API PHP", teste_api_php),
    ]
    
    resultados = {}
    for nome, funcao_teste in testes:
        try:
            resultados[nome] = funcao_teste()
        except Exception as e:
            print(f"✗ Erro ao executar teste {nome}: {e}")
            resultados[nome] = False
    
    # Resumo
    print("\n" + "=" * 80)
    print("📊 RESULTADO DOS TESTES")
    print("=" * 80)
    
    total = len(resultados)
    ok = sum(1 for v in resultados.values() if v)
    
    for nome, resultado in resultados.items():
        status = "✓ OK" if resultado else "✗ FALHA"
        print(f"{status:6} - {nome}")
    
    print("\n" + "=" * 80)
    print(f"RESULTADO: {ok}/{total} testes passaram")
    print("=" * 80)
    
    if ok == total:
        print("\n✓ Sistema PRONTO para rodar o robô!")
        print("\nProxímo passo:")
        print("  python rexmultitrade.py")
        return 0
    elif ok >= total - 1:  # API PHP é opcional no início
        print("\n⚠ Sistema pode rodar, mas verifique os avisos")
        return 0
    else:
        print("\n✗ Sistema NÃO está pronto - Corrija os erros acima")
        return 1

if __name__ == '__main__':
    sys.exit(main())
