from flask import Flask, render_template, jsonify, request
import os
import db_manager
import orchestrator
import whatsapp_connector
import config
import sys

app = Flask(__name__, template_folder='templates', static_folder='static')

# Garantindo que as tabelas estejam inicializadas
db_manager.init_db()

@app.route('/api/debug/python-path', methods=['GET'])
def debug_python_path():
    """Retorna o caminho exato do executável do Python rodando no servidor."""
    return jsonify({
        "python_executable": sys.executable,
        "cwd": os.getcwd()
    })

@app.route('/api/debug/find-all-node', methods=['GET'])
def find_all_node():
    """Varre os diretórios de sistema da VPS para localizar todas as versões do Node instaladas."""
    try:
        import os
        results = []
        # Busca executáveis 'node' em locais de sistema do cPanel
        search_paths = ["/opt", "/usr/local"]
        for path in search_paths:
            if os.path.exists(path):
                try:
                    for root, dirs, files in os.walk(path):
                        # Limita a profundidade para não dar timeout
                        depth = root.replace(path, '').count(os.sep)
                        if depth > 4:
                            dirs.clear()
                            continue
                        if 'node' in files:
                            node_path = os.path.join(root, 'node')
                            if os.access(node_path, os.X_OK):
                                results.append(node_path)
                except Exception as walk_err:
                    results.append(f"Erro em {path}: {str(walk_err)}")
        return jsonify({
            "node_binaries_found": results
        })
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/api/debug/read-other-htaccess', methods=['GET'])
def read_other_htaccess():
    """Lê os arquivos .htaccess de outros apps na pasta apps/ para verificar a configuração funcional do Passenger."""
    try:
        import os
        results = {}
        base_apps = "/home/grpia/apps"
        if os.path.exists(base_apps):
            for item in os.listdir(base_apps):
                item_path = os.path.join(base_apps, item)
                if os.path.isdir(item_path):
                    htaccess_path = os.path.join(item_path, ".htaccess")
                    if os.path.exists(htaccess_path):
                        try:
                            with open(htaccess_path, 'r') as f:
                                results[item] = f.read()
                        except Exception as e:
                            results[item] = f"Erro ao ler: {str(e)}"
                    else:
                        results[item] = "Não possui .htaccess"
        return jsonify(results)
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/api/debug/find-htaccess', methods=['GET'])
def find_htaccess():
    """Varre a conta do usuário /home/grpia/ para localizar todos os arquivos .htaccess."""
    try:
        import os
        results = []
        root_home = "/home/grpia"
        for root, dirs, files in os.walk(root_home):
            if any(p in root for p in ["node_modules", ".git", ".trash", "repositories"]):
                dirs.clear()
                continue
            depth = root.replace(root_home, '').count(os.sep)
            if depth > 3:
                dirs.clear()
                continue
            if '.htaccess' in files:
                results.append(os.path.join(root, '.htaccess'))
        return jsonify(results)
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/api/debug/read-crm-htaccess', methods=['GET'])
def read_crm_htaccess():
    """Lê o arquivo .htaccess do CRM antigo para ver as regras exatas do Passenger."""
    try:
        import os
        path = "/home/grpia/crm.grupoddm.ia.br/.htaccess"
        if os.path.exists(path):
            with open(path, 'r') as f:
                return jsonify({"content": f.read()})
        return jsonify({"message": f"Arquivo não encontrado: {path}"}), 404
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/api/debug/list-crm-files', methods=['GET'])
def list_crm_files():
    """Lista todos os arquivos na raiz do CRM novo para verificar o ponto de entrada."""
    try:
        import os
        path = "/home/grpia/apps/omnichannel"
        if os.path.exists(path):
            return jsonify(os.listdir(path))
        return jsonify({"message": f"Pasta não encontrada: {path}"}), 404
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/api/debug/read-server-js', methods=['GET'])
def read_server_js():
    """Lê o arquivo server.js da raiz do CRM para validar o ponto de entrada."""
    try:
        import os
        path = "/home/grpia/apps/omnichannel/server.js"
        if os.path.exists(path):
            with open(path, 'r') as f:
                return jsonify({"content": f.read()})
        return jsonify({"message": "server.js não encontrado"}), 404
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/api/debug/write-crm-boot', methods=['GET'])
def write_crm_boot():
    """Grava o código real do servidor de produção do Next.js em server.js e app.js."""
    try:
        import os
        crm_path = "/home/grpia/apps/omnichannel"
        if not os.path.exists(crm_path):
            return jsonify({"message": f"Pasta do CRM não encontrada: {crm_path}"}), 404
            
        boot_code = """const { createServer } = require('http');
const { parse } = require('url');
const next = require('next');

const dev = false;
const app = next({ dev });
const handle = app.getRequestHandler();

app.prepare().then(() => {
  createServer((req, res) => {
    const parsedUrl = parse(req.url, true);
    handle(req, res, parsedUrl);
  }).listen(process.env.PORT || 3000, (err) => {
    if (err) throw err;
    console.log('> Ready on http://localhost:' + (process.env.PORT || 3000));
  });
});
"""
        # Escreve nos dois nomes possíveis para garantir que o cPanel ache
        paths_to_write = [
            os.path.join(crm_path, "server.js"),
            os.path.join(crm_path, "app.js")
        ]
        
        written = []
        for path in paths_to_write:
            with open(path, "w") as f:
                f.write(boot_code)
            written.append(path)
            
        return jsonify({
            "success": True,
            "message": "Arquivos de inicialização de produção do Next.js gravados com sucesso!",
            "files_written": written
        })
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/api/debug/test-smtp', methods=['GET'])
def debug_test_smtp():
    """Testa a conexão e credenciais do SMTP e retorna o resultado ou erro detalhado."""
    try:
        import smtplib
        from email.mime.text import MIMEText
        import traceback
        
        if not config.EMAIL_USER or not config.EMAIL_PASS:
            return jsonify({"success": False, "message": "EMAIL_USER ou EMAIL_PASS não estão configurados no .env."}), 400
            
        msg = MIMEText("E-mail de diagnóstico de envio SMTP.")
        msg["From"] = config.EMAIL_USER
        msg["To"] = config.EMAIL_USER  # Envia para si mesmo
        msg["Subject"] = "Diagnóstico SMTP - Agente DDM"
        
        print("[Debug SMTP] Iniciando conexão com o SMTP...")
        server = smtplib.SMTP_SSL(config.EMAIL_SMTP_SERVER, 465, timeout=10)
        print("[Debug SMTP] Fazendo login...")
        server.login(config.EMAIL_USER, config.EMAIL_PASS)
        print("[Debug SMTP] Enviando e-mail...")
        server.sendmail(config.EMAIL_USER, [config.EMAIL_USER], msg.as_string())
        server.quit()
        
        return jsonify({"success": True, "message": "SMTP conectado e e-mail de teste enviado com sucesso!"})
    except Exception as e:
        return jsonify({
            "success": False,
            "error_type": type(e).__name__,
            "error_message": str(e),
            "traceback": traceback.format_exc()
        }), 500

@app.route('/api/debug/run-build', methods=['GET'])
def debug_run_build():
    """Executa o build do Next.js do CRM ativando o ambiente virtual do Node do cPanel."""
    try:
        import subprocess
        import os
        import traceback
        
        # Localiza dinamicamente a pasta da versão do Node na pasta do nodevenv do omnichannel
        base_nodevenv = "/home/grpia/nodevenv/apps/omnichannel"
        
        # Vamos fazer uma busca ampla caso o caminho padrão não exista
        node_executable = None
        activate_path = None
        
        # 1. Tenta os caminhos padrão do usuário
        probable_paths = [
            "/home/grpia/nodevenv/apps/omnichannel/20/bin/activate",
            "/home/grpia/nodevenv/apps/omnichannel/18/bin/activate",
            "/home/grpia/nodevenv/apps/omnichannel/22/bin/activate",
        ]
        
        for path in probable_paths:
            if os.path.exists(path):
                activate_path = path
                break
                
        # 2. Se não achou, procura por versões do Node 20/22/18 instaladas no sistema
        if not activate_path:
            system_node_paths = [
                "/opt/cpanel/ea-nodejs22/bin",
                "/opt/alt/alt-nodejs20/root/usr/bin",
                "/opt/alt/alt-nodejs22/root/usr/bin",
                "/opt/alt/alt-nodejs18/root/usr/bin",
                "/usr/bin",
                "/usr/local/bin"
            ]
            for path in system_node_paths:
                potential_node = os.path.join(path, "node")
                if os.path.exists(potential_node):
                    node_executable = potential_node
                    break
                    
        # 3. Se não achou nada, lista a raiz /home/grpia para diagnóstico
        scan_results = []
        if not activate_path and not node_executable:
            try:
                scan_results = os.listdir("/home/grpia")
            except Exception as e:
                scan_results.append(f"Erro ao listar raiz: {str(e)}")
                
        if not activate_path and not node_executable:
            return jsonify({
                "success": False, 
                "message": "Não foi possível encontrar o Node ou NVM no servidor.",
                "conteudo_raiz_home": scan_results
            }), 400
            
        # 4. Monta o comando de execução baseado no que foi encontrado
        if activate_path:
            print("[Debug Build] Rodando 'npm run build' com NODE_ENV=production usando virtualenv...")
            cmd = f"export NODE_ENV=production && source {activate_path} && cd /home/grpia/apps/omnichannel && npm run build"
        elif node_executable:
            print(f"[Debug Build] Rodando 'npm run build' com NODE_ENV=production usando o Node: {node_executable}...")
            node_dir = os.path.dirname(node_executable)
            cmd = f"export NODE_ENV=production && export PATH={node_dir}:$PATH && cd /home/grpia/apps/omnichannel && npm run build"
        else:
            print("[Debug Build] Rodando 'npm run build' com NVM...")
            cmd = (
                "export NODE_ENV=production && "
                "export NVM_DIR=/home/grpia/.nvm && "
                "source $NVM_DIR/nvm.sh && "
                "nvm use 20.19.0 && "
                "cd /home/grpia/apps/omnichannel && "
                "npm run build"
            )
        
        result = subprocess.run(
            cmd,
            shell=True,
            executable='/bin/bash',  # Necessário bash para suportar o comando 'source'
            capture_output=True,
            text=True,
            timeout=300  # Limite de 5 minutos para o build completo
        )
        
        # Se falhar, faz uma varredura para nos ajudar a encontrar o Node 20
        home_contents = []
        if result.returncode != 0:
            try:
                home_contents = os.listdir("/home/grpia")
            except Exception as e:
                home_contents = [f"Erro ao listar home: {str(e)}"]
        
        return jsonify({
            "success": result.returncode == 0,
            "returncode": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr,
            "path_usado": activate_path or node_executable or "nvm",
            "pastas_no_home_do_usuario": home_contents
        })
    except Exception as e:
        return jsonify({
            "success": False,
            "error": str(e),
            "traceback": traceback.format_exc()
        })