import logging
import sys
import psycopg2
import config
import requests
from datetime import datetime
from psycopg2.extras import RealDictCursor

def buscar_status_3():
    conn = psycopg2.connect(
        host=config.DB_HOST,
        database=config.DB_NAME,
        user=config.DB_USER,
        password=config.DB_PASS
    )
    cur = conn.cursor()

    cur.execute("""
        SELECT roboxxt035, telefot035
          FROM dsr035
         WHERE statust035 = 3
    """)

    rows = cur.fetchall()
    conn.close()

    return rows
    
def processar_status_3():
    logger = logging.getLogger(__name__)
    registros = buscar_status_3()

    for robo, telefone in registros:
        mensagem = 'Por favor, reenvie o código!'
        envia_whatsapp(
            telefone,
            mensagem,
            delay_ms=5000,
            presence="composing"
        )
        logger.warning("Mensagem enviada para %s", telefone)

        try:
            conn = psycopg2.connect(
                host=config.DB_HOST,
                database=config.DB_NAME,
                user=config.DB_USER,
                password=config.DB_PASS
            )
            cur = conn.cursor()

            cur.execute("""
                UPDATE dsr035
                   SET statust035 = %s
                 WHERE telefot035 = %s
            """, (1, telefone))

            conn.commit()
            conn.close()

            logger.info("Status resetado para 1 (%s)", telefone)

        except Exception as e:
            logger.exception("Erro ao atualizar status 3: %s", e)

def conecta_dsr037():   
    logger = logging.getLogger(__name__)

    try:
        conn = psycopg2.connect(
            host=config.DB_HOST,
            database=config.DB_NAME,
            user=config.DB_USER,
            password=config.DB_PASS
        )

        cur = conn.cursor(cursor_factory=RealDictCursor)

        cur.execute("""
            SELECT
                roboxxt037, 
                nomcolt037, 
                titcolt037, 
                datprot037, 
                horprot037, 
                qtdlant037
            FROM dsr037
        """)

        registros = cur.fetchall()
        logger.info("Registros encontrados: %s", len(registros))
        return registros

    except Exception:
        logger.exception("Erro ao conectar/buscar dsr037")
        return []

    finally:
        try:
            cur.close()
            conn.close()
        except:
            pass
            
def conecta_dsr035(roboxxt037):
    logger = logging.getLogger(__name__)

    try:
        conn = psycopg2.connect(
            host=config.DB_HOST,
            database=config.DB_NAME,
            user=config.DB_USER,
            password=config.DB_PASS
        )

        cur = conn.cursor(cursor_factory=RealDictCursor)

        cur.execute("""
            SELECT telefot035
              FROM dsr035
             WHERE roboxxt035 = %s
        """, (roboxxt037,))

        row = cur.fetchone()

        if not row:
            logger.warning("Telefone não encontrado para robô %s", roboxxt037)
            return None

        return str(row["telefot035"])

    except Exception:
        logger.exception("Erro ao buscar telefone na dsr035")
        return None

    finally:
        try:
            cur.close()
            conn.close()
        except:
            pass

def reset_dsr037():   
    logger = logging.getLogger(__name__)
    
    agora = datetime.now()
    hora_atual = agora.strftime("%H%M%S")
    data_atual = agora.strftime("%Y%m%d")

    try:
        conn = psycopg2.connect(
            host=config.DB_HOST,
            database=config.DB_NAME,
            user=config.DB_USER,
            password=config.DB_PASS
        )

        cur = conn.cursor(cursor_factory=RealDictCursor)

        cur.execute("""
            UPDATE dsr037
               SET datprot037 = %s,
                   horprot037 = %s
        """, (data_atual, hora_atual))
        conn.commit()
        logger.info(f"Tabela dsr037 atualizada com data={data_atual} e hora={hora_atual}")

    except Exception as e:
        logger.error(f"Erro ao atualizar dsr037: {e}")
        raise

    finally:
        try:
            cur.close()
            conn.close()
        except:
            pass        

def pegar_status(roboxxt037):
    logger = logging.getLogger(__name__)
    
    conn = None
    cur = None

    try:
        conn = psycopg2.connect(
            host=config.DB_HOST,
            database=config.DB_NAME,
            user=config.DB_USER,
            password=config.DB_PASS
        )

        cur = conn.cursor(cursor_factory=RealDictCursor)

        cur.execute("""
            SELECT statust035
            FROM dsr035
            WHERE roboxxt035 = %s
        """, (roboxxt037,))

        row = cur.fetchone()

        return row["statust035"]

    except Exception as e:
        logger.exception("Erro ao pegar status do robô: %s", e)
        return None

    finally:
        if cur:
            cur.close()
        if conn:
            conn.close()

def calcula_intervalo(datprot037, horprot037, roboxxt037, telefone):
    logger = logging.getLogger(__name__)
        
    # Junta data + hora do banco
    ultima_atividade = datetime.strptime(
        f"{datprot037}{horprot037}",
        "%Y%m%d%H%M%S"
    )

    agora = datetime.now()
    intervalo = (agora - ultima_atividade).total_seconds()

    logger.info(
        "Robô %s parado há %.0f segundos",
        roboxxt037,
        intervalo
    )

    if intervalo >= 180:
        novo_status = 2
        logger.warning("Robô %s INATIVO (3 minutos)", roboxxt037)
        mensagem = 'Aguardando retorno do TSE'
    #    envia_whatsapp(telefone, mensagem, delay_ms=5000, presence="composing")
    elif intervalo >= 120:
        logger.info("Robô %s parado há 2 minutos", roboxxt037)
        mensagem = 'Aguardando retorno do TSE'
    #    envia_whatsapp(telefone, mensagem, delay_ms=5000, presence="composing")
        return
    elif intervalo >= 60:
        logger.info("Robô %s parado há 1 minuto", roboxxt037)
        mensagem = 'Aguardando retorno do TSE'
    #    envia_whatsapp(telefone, mensagem, delay_ms=5000, presence="composing")
        return
    else:
        return

    # Atualiza status no banco
    try:
        conn = psycopg2.connect(
            host=config.DB_HOST,
            database=config.DB_NAME,
            user=config.DB_USER,
            password=config.DB_PASS
        )
        cur = conn.cursor()
        
        cur.execute("""
            SELECT statust035
              FROM dsr035
             WHERE roboxxt035 = %s
        """, (roboxxt037,))

        status_atual = cur.fetchone()

        if status_atual and status_atual[0] == 2:
            logger.info("Robô %s já está INATIVO, ignorando update", roboxxt037)
            return

        cur.execute("""
            UPDATE dsr035
               SET statust035 = %s
             WHERE roboxxt035 = %s
        """, (novo_status, roboxxt037))

        conn.commit()
        logger.info("Status do robô %s atualizado para %s", roboxxt037, novo_status)
        mensagem = 'Não conseguimos comunicação com o TSE. Você será avisado quando reestabelecermos a conexão'
        envia_whatsapp(telefone, mensagem, delay_ms=5000, presence="composing")

    except Exception:
        logger.exception("Erro ao atualizar status do robô")

    finally:
        try:
            cur.close()
            conn.close()
        except:
            pass
 
def envia_whatsapp(numero, mensagem, delay_ms=5000, presence="composing"):
    logger = logging.getLogger(__name__)
    if isinstance(numero, Decimal):
        numero = format(numero, 'f')

    numero = str(numero).strip()

    url = "https://api-prd.joindeveloper.com.br/mensagens/enviartexto"

    headers = {
        "tokenCliente": config.JOIN_TOKEN_CLIENTE,
        "instancia": config.JOIN_INSTANCIA,
        "Content-Type": "application/json"
    }

    payload = {
        "number": numero,
        "options": {
            "delay": delay_ms,
            "presence": presence
        },
        "textMessage": {
            "text": mensagem
        }
    }

    try:
        response = requests.post(
            url,
            json=payload,
            headers=headers,
            timeout=15
        )

        if response.status_code == 200:
            logger.info("WhatsApp enviado para %s", numero)
            return True
        else:
            logger.error(
                "Erro ao enviar WhatsApp (%s): %s",
                response.status_code,
                response.text
            )
            return False

    except Exception:
        logger.exception("Falha ao enviar WhatsApp")
        return False