import os
import smtplib
from datetime import datetime
from email.mime.text import MIMEText
from pathlib import Path

import pytz
import requests
from dotenv import load_dotenv


# Carrega .env sempre pelo caminho do projeto (independente do CWD)
BASE_DIR = Path(__file__).resolve().parent
load_dotenv(dotenv_path=BASE_DIR / ".env")


EVOLUTION_API_URL = os.getenv("EVOLUTION_API_URL")
EVOLUTION_INSTANCE_ID = os.getenv("EVOLUTION_INSTANCE_ID")
EVOLUTION_API_TOKEN = os.getenv("EVOLUTION_API_TOKEN")
EVOLUTION_SENDER_INSTANCE = os.getenv("EVOLUTION_SENDER_INSTANCE", "Wander")
N8N_WEBHOOK_URL = os.getenv("N8N_WEBHOOK_URL")
WHATSAPP_NUMBER = os.getenv("WHATSAPP_NUMBER")
SMTP_SERVER = os.getenv("SMTP_SERVER", "smtp-mail.outlook.com")
SMTP_PORT = int(os.getenv("SMTP_PORT", 587))
SMTP_EMAIL = os.getenv("SMTP_EMAIL")
SMTP_PASSWORD = os.getenv("SMTP_PASSWORD")
EMAIL_TO = os.getenv("EMAIL_TO")

TIMEZONE = os.getenv("TIMEZONE", "America/Sao_Paulo")
tz = pytz.timezone(TIMEZONE)


def _normalize_env(value):
    if value is None:
        return None
    cleaned = value.strip()
    return cleaned if cleaned else None


def _required_env_missing():
    required = {
        "EVOLUTION_API_URL": _normalize_env(EVOLUTION_API_URL),
        "EVOLUTION_API_TOKEN": _normalize_env(EVOLUTION_API_TOKEN),
        "EVOLUTION_SENDER_INSTANCE": _normalize_env(EVOLUTION_SENDER_INSTANCE),
        "N8N_WEBHOOK_URL": _normalize_env(N8N_WEBHOOK_URL),
        "SMTP_EMAIL": _normalize_env(SMTP_EMAIL),
        "SMTP_PASSWORD": _normalize_env(SMTP_PASSWORD),
        "EMAIL_TO": _normalize_env(EMAIL_TO),
        "WHATSAPP_NUMBER": _normalize_env(WHATSAPP_NUMBER),
    }
    return [name for name, value in required.items() if not value]


def get_now():
    return datetime.now(tz)


def get_headers():
    token = _normalize_env(EVOLUTION_API_TOKEN) or ""
    return {
        "apikey": token,
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    }


def send_email_error(error_details):
    try:
        now = get_now()
        subject = "ERRO - Monitor Evolution API"
        body = (
            "Falha no monitoramento.\n"
            f"Horario: {now.strftime('%d/%m/%Y %H:%M:%S')}\n\n"
            f"Detalhes do Erro:\n{error_details}"
        )

        msg = MIMEText(body)
        msg["Subject"] = subject
        msg["From"] = SMTP_EMAIL
        msg["To"] = EMAIL_TO

        smtp_security = os.getenv("SMTP_SECURITY", "STARTTLS").upper()

        if smtp_security == "SSL":
            server = smtplib.SMTP_SSL(SMTP_SERVER, SMTP_PORT)
        else:
            server = smtplib.SMTP(SMTP_SERVER, SMTP_PORT)
            if smtp_security == "STARTTLS":
                server.starttls()

        with server:
            server.login(SMTP_EMAIL, SMTP_PASSWORD)
            server.send_message(msg)

        return True, "Email de erro enviado com sucesso."
    except Exception as exc:
        return False, f"Falha ao enviar email: {exc}"


def send_whatsapp_success():
    try:
        base_url = (_normalize_env(EVOLUTION_API_URL) or "").rstrip("/")
        sender_instance = _normalize_env(EVOLUTION_SENDER_INSTANCE) or "Wander"
        url = f"{base_url}/message/sendText/{sender_instance}"

        now = get_now()
        message_text = (
            "MONITOR OK\n\n"
            f"Data: {now.strftime('%d/%m/%Y')}\n"
            f"Horario: {now.strftime('%H:%M:%S')}\n\n"
            "• Evolution API: Online\n"
            "• Webhook Instancia: Habilitado\n"
            "• Webhook N8N: Funcionando\n\n"
            "Todos os servicos operacionais."
        )

        payload = {"number": WHATSAPP_NUMBER, "text": message_text}
        response = requests.post(url, json=payload, headers=get_headers(), timeout=10)

        if response.status_code in (200, 201):
            return True, "WhatsApp de sucesso enviado."
        return False, f"Falha ao enviar WhatsApp: {response.text}"
    except Exception as exc:
        return False, f"Erro na requisicao WhatsApp: {exc}"


def run_monitor_check():
    log_messages = []
    whatsapp_status = "-"
    email_status = "-"

    missing_env = _required_env_missing()
    if missing_env:
        log_messages.append(f"❌ Configuracao ausente no .env: {', '.join(missing_env)}")
        return False, log_messages, whatsapp_status, email_status

    base_url = (_normalize_env(EVOLUTION_API_URL) or "").rstrip("/")
    sender_instance = _normalize_env(EVOLUTION_SENDER_INSTANCE) or "Wander"
    webhook_n8n_url = _normalize_env(N8N_WEBHOOK_URL)

    # Passo 1: Health Evolution API
    try:
        health_url = f"{base_url}/instance/connectionState/{sender_instance}"
        resp_health = requests.get(health_url, headers=get_headers(), timeout=10)

        if resp_health.status_code == 200:
            try:
                data = resp_health.json()
                instance_data = data.get("instance", {})
                state = instance_data.get("state") or data.get("state")

                if state == "open":
                    log_messages.append("✅ Evolution API Online")
                else:
                    error_msg = f"Evolution API Desconectada (State: {state})"
                    log_messages.append(f"❌ {error_msg}")
                    email_ok, _ = send_email_error(error_msg)
                    email_status = "Sucesso" if email_ok else "Erro"
                    return False, log_messages, whatsapp_status, email_status
            except Exception:
                raw_text = (resp_health.text or "").strip().lower()
                if raw_text.startswith("<!doctype") or raw_text.startswith("<html"):
                    error_msg = "Evolution API retornou HTML (possivel erro de autenticacao)"
                elif raw_text:
                    error_msg = "Evolution API retornou JSON invalido"
                else:
                    error_msg = "Evolution API retornou resposta vazia"

                log_messages.append(f"❌ {error_msg}")
                email_ok, _ = send_email_error(error_msg)
                email_status = "Sucesso" if email_ok else "Erro"
                return False, log_messages, whatsapp_status, email_status
        else:
            error_msg = f"Evolution API Offline. Status: {resp_health.status_code}"
            log_messages.append(f"❌ {error_msg}")
            email_ok, _ = send_email_error(error_msg)
            email_status = "Sucesso" if email_ok else "Erro"
            return False, log_messages, whatsapp_status, email_status
    except Exception as exc:
        error_msg = f"Erro ao conectar na Evolution API: {exc}"
        log_messages.append(f"❌ {error_msg}")
        email_ok, _ = send_email_error(error_msg)
        email_status = "Sucesso" if email_ok else "Erro"
        return False, log_messages, whatsapp_status, email_status

    # Passo 1.5: Webhook da instancia
    try:
        webhook_url = f"{base_url}/webhook/find/{sender_instance}"
        resp_webhook_config = requests.get(webhook_url, headers=get_headers(), timeout=15)

        if resp_webhook_config.status_code == 200:
            webhook_data = resp_webhook_config.json()
            webhook_enabled = webhook_data.get("enabled", False)

            if webhook_enabled:
                log_messages.append("✅ Webhook Instancia OK")
            else:
                error_msg = "Webhook da Instancia DESABILITADO"
                log_messages.append(f"❌ {error_msg}")
                email_ok, _ = send_email_error(error_msg)
                email_status = "Sucesso" if email_ok else "Erro"
                return False, log_messages, whatsapp_status, email_status
        else:
            log_messages.append(
                f"⚠️ Nao foi possivel verificar webhook da instancia "
                f"(Status: {resp_webhook_config.status_code})"
            )
    except Exception as exc:
        log_messages.append(f"⚠️ Erro ao verificar webhook da instancia: {str(exc)[:80]}")

    # Passo 2: Teste webhook N8N
    try:
        resp_webhook = requests.post(webhook_n8n_url, json={"check": "ping"}, timeout=10)
        if resp_webhook.status_code == 200:
            log_messages.append("✅ Webhook N8N OK")
        else:
            error_msg = f"Webhook N8N falhou. Status: {resp_webhook.status_code}"
            log_messages.append(f"❌ {error_msg}")
            email_ok, _ = send_email_error(error_msg)
            email_status = "Sucesso" if email_ok else "Erro"
            return False, log_messages, whatsapp_status, email_status
    except Exception as exc:
        error_msg = f"Erro ao conectar no Webhook N8N: {exc}"
        log_messages.append(f"❌ {error_msg}")
        email_ok, _ = send_email_error(error_msg)
        email_status = "Sucesso" if email_ok else "Erro"
        return False, log_messages, whatsapp_status, email_status

    # Passo 3: Notificacao de sucesso via WhatsApp
    success, msg = send_whatsapp_success()
    if success:
        log_messages.append(f"✅ {msg}")
        whatsapp_status = "Sucesso"
        return True, log_messages, whatsapp_status, email_status

    whatsapp_status = "Erro"
    error_msg = f"Servicos online, mas falha ao enviar WhatsApp: {msg}"
    log_messages.append(f"⚠️ {error_msg}")
    email_ok, _ = send_email_error(error_msg)
    email_status = "Sucesso" if email_ok else "Erro"
    return False, log_messages, whatsapp_status, email_status


def diagnose_n8n_webhook():
    try:
        url = _normalize_env(N8N_WEBHOOK_URL)
        now = get_now()
        payload = {"check": "diagnosis_ping", "timestamp": str(now)}

        log = {
            "url": url,
            "method": "POST",
            "payload_sent": payload,
            "status_code": None,
            "response_body": None,
            "headers_received": None,
            "error": None,
        }

        if not url:
            log["error"] = "N8N_WEBHOOK_URL nao configurada no .env"
            return False, log

        response = requests.post(url, json=payload, timeout=10)
        log["status_code"] = response.status_code
        log["response_body"] = response.text
        log["headers_received"] = dict(response.headers)
        return response.status_code == 200, log
    except Exception as exc:
        return False, {
            "url": _normalize_env(N8N_WEBHOOK_URL),
            "method": "POST",
            "payload_sent": None,
            "status_code": None,
            "response_body": None,
            "headers_received": None,
            "error": str(exc),
        }


if __name__ == "__main__":
    status, logs, wa_status, em_status = run_monitor_check()
    print(f"Status: {status}")
    print(f"WhatsApp: {wa_status} | Email: {em_status}")
    print("\n".join(logs))