// ============================================================
// @CanalQb — TRON Vote Monitor v2.0
// Google Apps Script — Módulo Core
// Docs: https://developers.google.com/apps-script
// API: https://developers.tron.network/reference
// ============================================================

// ──── CONFIGURAÇÃO (edite aqui) ────
const CONFIG = {
  address:       "SEU_ENDEREÇO_TRON_AQUI",
  telegramToken: "SEU_BOT_TOKEN",
  telegramChatId:"SEU_CHAT_ID",
  firebaseUrl:   "https://seu-projeto.firebaseio.com",
  firebaseSecret:"SEU_FIREBASE_SECRET",
  rankThreshold: 27,    // Alerta se SR sair deste rank
  prodThreshold: 98.5,  // Alerta se produtividade cair abaixo disto (%)
  aprDropAlert:  0.3    // Alerta se APR carteira cair mais que 0.3% em 24h
};

// ──── ENDPOINT TronScan API ────
const API = {
  votes: "https://apilist.tronscanapi.com/api/vote?address=",
  srs:   "https://apilist.tronscanapi.com/api/sr/list",
  sr27:  "https://apilist.tronscanapi.com/api/sr/committee"
};

// ──── FUNÇÃO PRINCIPAL — chame esta via Trigger ────
function runMonitor() {
  const votes    = fetchMyVotes();
  const srData   = fetchSRData();
  const portfolio= buildPortfolio(votes, srData);
  const apr      = calcPortfolioAPR(portfolio);
  const alerts   = detectAlerts(portfolio, apr);

  saveToFirebase(portfolio, apr);

  if (alerts.length > 0) {
    sendTelegram(formatAlertMsg(alerts, apr));
  }

  updateDashboardSheet(portfolio, apr, alerts);
  Logger.log("Monitor concluído. APR atual: " + apr.toFixed(2) + "%");
}

// ──── BUSCAR MEUS VOTOS ────
function fetchMyVotes() {
  try {
    const res  = UrlFetchApp.fetch(API.votes + CONFIG.address, {muteHttpExceptions: true});
    const json = JSON.parse(res.getContentText());
    if (!json.data) throw new Error("Endereço inválido ou sem votos");
    return json.data.map(v => ({
      name:    v.candidateName    || v.candidateAddress,
      address: v.candidateAddress,
      votes:   parseInt(v.voteCount) || 0
    }));
  } catch(e) {
    Logger.log("Erro fetchMyVotes: " + e.message);
    return [];
  }
}

// ──── BUSCAR DADOS DOS SRS (rank, APR, produtividade) ────
function fetchSRData() {
  try {
    const res  = UrlFetchApp.fetch(API.srs, {muteHttpExceptions: true});
    const json = JSON.parse(res.getContentText());
    const srMap = {};
    (json.data || []).forEach(sr => {
      srMap[sr.address] = {
        name:         sr.url || sr.name,
        rank:         parseInt(sr.realTimeRanking) || 999,
        votes:        parseInt(sr.realTimeVotes)   || 0,
        productivity: parseFloat(sr.productivity)  || 0,
        apr:          parseFloat(sr.annualizedRate) || 0,
        isActive:     parseInt(sr.realTimeRanking) <= CONFIG.rankThreshold
      };
    });
    return srMap;
  } catch(e) {
    Logger.log("Erro fetchSRData: " + e.message);
    return {};
  }
}

// ──── MONTAR PORTFOLIO ENRIQUECIDO ────
function buildPortfolio(votes, srData) {
  return votes.map(v => {
    const sr = srData[v.address] || {};
    return {
      ...v,
      rank:         sr.rank         || 999,
      productivity: sr.productivity || 0,
      apr:          sr.apr          || 0,
      isActive:     sr.isActive     || false,
      risk:         calcRisk(sr)
    };
  });
}

// ──── CALCULAR RISCO DO SR (score 0–100) ────
function calcRisk(sr) {
  if (!sr.rank) return 100;
  let risk = 0;
  if (sr.rank > 20)   risk += 30;  // perto do limite
  if (sr.rank > 25)   risk += 40;  // zona de risco
  if (sr.productivity < 99) risk += 15;
  if (sr.productivity < 98) risk += 25;
  if (sr.votes < 500000000) risk += 20; // base de votos fraca
  return Math.min(risk, 100);
}

// ──── CALCULAR APR REAL PONDERADO DA CARTEIRA ────
function calcPortfolioAPR(portfolio) {
  const totalVotes = portfolio.reduce((s, p) => s + p.votes, 0);
  if (totalVotes === 0) return 0;

  // APR ponderado apenas pelos SRs ATIVOS (rank ≤ 27)
  const activeVotes = portfolio.filter(p => p.isActive);
  const weightedSum = activeVotes.reduce((s, p) => s + (p.apr * p.votes), 0);
  const activeTotal = activeVotes.reduce((s, p) => s + p.votes, 0);

  // Votos em SRs inativos = APR 0 — inclui na média total
  return activeTotal > 0 ? (weightedSum / totalVotes) : 0;
}

// ──── DETECTAR ALERTAS ────
function detectAlerts(portfolio, currentAPR) {
  const alerts = [];

  portfolio.forEach(p => {
    if (!p.isActive) {
      alerts.push({ type: "RANK_OUT", sr: p.name, rank: p.rank, severity: "CRITICO" });
    } else if (p.rank > 24) {
      alerts.push({ type: "RANK_RISK", sr: p.name, rank: p.rank, severity: "AVISO" });
    }
    if (p.productivity < CONFIG.prodThreshold) {
      alerts.push({ type: "LOW_PROD", sr: p.name, prod: p.productivity, severity: "AVISO" });
    }
    if (p.risk >= 70) {
      alerts.push({ type: "HIGH_RISK", sr: p.name, risk: p.risk, severity: "ATENCAO" });
    }
  });

  // Verifica queda de APR comparada ao histórico Firebase
  const lastAPR = getLastAPRFromFirebase();
  if (lastAPR && (lastAPR - currentAPR) > CONFIG.aprDropAlert) {
    alerts.push({ type: "APR_DROP", prev: lastAPR, curr: currentAPR, severity: "CRITICO" });
  }

  return alerts;
}

// ──── FORMATAR MENSAGEM TELEGRAM ────
function formatAlertMsg(alerts, apr) {
  let msg = "🚨 *TRON Vote Monitor — @CanalQb*\n\n";
  msg += "📊 APR atual da carteira: *" + apr.toFixed(2) + "%*\n\n";
  alerts.forEach(a => {
    const icon = a.severity === "CRITICO" ? "🔴" : a.severity === "AVISO" ? "🟡" : "🟠";
    switch(a.type) {
      case "RANK_OUT":
        msg += icon + " SR *"+a.sr+"* FORA do TOP27 (rank: "+a.rank+")\n"; break;
      case "RANK_RISK":
        msg += icon + " SR *"+a.sr+"* em zona de risco (rank: "+a.rank+")\n"; break;
      case "LOW_PROD":
        msg += icon + " SR *"+a.sr+"* produtividade baixa: "+a.prod.toFixed(1)+"%\n"; break;
      case "APR_DROP":
        msg += icon + " APR caiu de "+a.prev.toFixed(2)+"% → "+a.curr.toFixed(2)+"%\n"; break;
      case "HIGH_RISK":
        msg += icon + " SR *"+a.sr+"* score de risco: "+a.risk+"/100\n"; break;
    }
  });
  msg += "\n🔗 canalqb.com.br";
  return msg;
}

// ──── ENVIAR ALERTA TELEGRAM ────
function sendTelegram(msg) {
  try {
    const url = "https://api.telegram.org/bot" + CONFIG.telegramToken + "/sendMessage";
    UrlFetchApp.fetch(url, {
      method: "post",
      contentType: "application/json",
      payload: JSON.stringify({ chat_id: CONFIG.telegramChatId, text: msg, parse_mode: "Markdown" }),
      muteHttpExceptions: true
    });
  } catch(e) { Logger.log("Erro Telegram: " + e.message); }
}

// ──── SALVAR HISTÓRICO NO FIREBASE ────
function saveToFirebase(portfolio, apr) {
  try {
    const snapshot = {
      timestamp: new Date().toISOString(),
      apr: apr,
      portfolio: portfolio
    };
    const url = CONFIG.firebaseUrl + "/history.json?auth=" + CONFIG.firebaseSecret;
    UrlFetchApp.fetch(url, {
      method: "post",
      contentType: "application/json",
      payload: JSON.stringify(snapshot),
      muteHttpExceptions: true
    });
  } catch(e) { Logger.log("Erro Firebase: " + e.message); }
}

// ──── LER ÚLTIMO APR DO FIREBASE (para comparação) ────
function getLastAPRFromFirebase() {
  try {
    const url = CONFIG.firebaseUrl + "/history.json?auth=" + CONFIG.firebaseSecret
              + "&orderBy=\"timestamp\"&limitToLast=2";
    const res  = UrlFetchApp.fetch(url, {muteHttpExceptions: true});
    const data = JSON.parse(res.getContentText());
    const keys = Object.keys(data);
    if (keys.length < 2) return null;
    return data[keys[keys.length - 2]].apr;
  } catch(e) { return null; }
}

// ──── ATUALIZAR ABA DASHBOARD NO GOOGLE SHEETS ────
function updateDashboardSheet(portfolio, apr, alerts) {
  try {
    const ss    = SpreadsheetApp.getActiveSpreadsheet();
    const sheet = ss.getSheetByName("DASHBOARD") || ss.insertSheet("DASHBOARD");
    sheet.clearContents();

    sheet.getRange("A1").setValue("APR Real Carteira");
    sheet.getRange("B1").setValue(apr.toFixed(2) + "%");
    sheet.getRange("A2").setValue("Atualizado");
    sheet.getRange("B2").setValue(new Date().toLocaleString("pt-BR"));
    sheet.getRange("A3").setValue("Alertas Ativos");
    sheet.getRange("B3").setValue(alerts.length);

    sheet.getRange("A5:F5").setValues([["SR","Votos","Rank","Produt%","APR%","Risco"]]);
    portfolio.forEach((p, i) => {
      sheet.getRange(6+i, 1, 1, 6).setValues([[p.name, p.votes, p.rank,
        p.productivity.toFixed(1), p.apr.toFixed(2), p.risk]]);
    });
  } catch(e) { Logger.log("Erro Sheet: " + e.message); }
}

# @CanalQb — TRON Vote Monitor via GitHub Actions
# Executa a cada 6 horas (ciclo TRON de recompensas)
# Repositório: github.com/SEU_USER/tron-vote-monitor

name: TRON Vote Monitor

on:
  schedule:
    # Roda às 00h, 06h, 12h e 18h UTC
    - cron: '0 0,6,12,18 * * *'
  workflow_dispatch:  # permite execução manual

jobs:
  monitor:
    runs-on: ubuntu-latest

    steps:
      - name: Trigger Google Apps Script
        run: |
          curl -L \
            -X GET \
            "${{ secrets.GAS_WEBHOOK_URL }}" \
            -H "Content-Type: application/json" \
            --max-time 60 \
            --retry 3 \
            --retry-delay 10

      - name: Log de execução
        run: echo "Monitor TRON executado em $(date -u)"

      - name: Notifica falha no Telegram
        if: failure()
        run: |
          curl -X POST "https://api.telegram.org/bot${{ secrets.TELEGRAM_TOKEN }}/sendMessage" \
            -d "chat_id=${{ secrets.TELEGRAM_CHAT_ID }}" \
            -d "text=⚠️ TRON Monitor: GitHub Action falhou em $(date -u)" \
            -d "parse_mode=Markdown"

// ============================================================
// @CanalQb — Módulo Firebase + FCM Push Notifications
// Integração com Firebase Admin SDK via REST API
// Docs Firebase: https://firebase.google.com/docs/cloud-messaging
// ============================================================

// ──── CONFIG FCM (adicione ao CONFIG principal) ────
const FCM_CONFIG = {
  projectId:    "seu-projeto-firebase",
  serverKey:    "SEU_FCM_SERVER_KEY",  // Console Firebase → Configurações do projeto → Cloud Messaging
  topicTron:    "tron_alerts"           // tópico FCM — assine no app cliente
};

// ──── ENVIAR PUSH NOTIFICATION VIA FCM (para apps) ────
function sendFCMPush(title, body, data) {
  const url = "https://fcm.googleapis.com/fcm/send";
  const payload = {
    to: "/topics/" + FCM_CONFIG.topicTron,
    notification: { title: title, body: body },
    data: data || {},
    android: { priority: "high" },
    apns: { headers: { "apns-priority": "10" } }
  };

  const options = {
    method: "post",
    contentType: "application/json",
    headers: { Authorization: "key=" + FCM_CONFIG.serverKey },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true
  };

  const res = UrlFetchApp.fetch(url, options);
  Logger.log("FCM Push enviado: " + res.getResponseCode());
}

// ──── SALVAR SNAPSHOT COMPLETO COM ESTRUTURA OTIMIZADA ────
// Use esta função no lugar da saveToFirebase básica do Core
function saveSnapshotToFirebase(portfolio, apr) {
  const now = new Date();
  const key = now.toISOString().replace(/[:.]/g, "-");

  const snapshot = {
    ts:        now.toISOString(),
    epoch:     now.getTime(),
    apr:       parseFloat(apr.toFixed(4)),
    totalVotes: portfolio.reduce((s,p) => s + p.votes, 0),
    activeSRs:  portfolio.filter(p => p.isActive).length,
    riskScore:  Math.round(portfolio.reduce((s,p) => s + p.risk, 0) / portfolio.length),
    srs: portfolio.map(p => ({
      name: p.name, votes: p.votes, rank: p.rank,
      apr: p.apr, prod: p.productivity, risk: p.risk, active: p.isActive
    }))
  };

  // Salvar em /snapshots/{key}
  const urlSnap = CONFIG.firebaseUrl + "/snapshots/" + key + ".json?auth=" + CONFIG.firebaseSecret;
  UrlFetchApp.fetch(urlSnap, { method:"put", contentType:"application/json", payload:JSON.stringify(snapshot), muteHttpExceptions:true });

  // Atualizar /latest para leitura rápida no app
  const urlLatest = CONFIG.firebaseUrl + "/latest.json?auth=" + CONFIG.firebaseSecret;
  UrlFetchApp.fetch(urlLatest, { method:"put", contentType:"application/json", payload:JSON.stringify(snapshot), muteHttpExceptions:true });

  Logger.log("Snapshot salvo: " + key);
}

// ──── DISPARAR PUSH + TELEGRAM PARA ALERTAS CRÍTICOS ────
function dispatchAlerts(alerts, apr) {
  if (alerts.length === 0) return;

  const critical = alerts.filter(a => a.severity === "CRITICO");
  const warnings = alerts.filter(a => a.severity !== "CRITICO");

  // Push FCM para todos os alertas
  sendFCMPush(
    critical.length > 0 ? "🔴 TRON: Alerta Crítico" : "🟡 TRON: Aviso",
    alerts.length + " eventos. APR: " + apr.toFixed(2) + "%",
    { alerts: JSON.stringify(alerts), apr: String(apr) }
  );

  // Telegram para críticos + avisos
  sendTelegram(formatAlertMsg(alerts, apr));
}

// ──── LEITURA DO HISTÓRICO (últimas N entradas) ────
function getHistory(limit) {
  limit = limit || 30;
  const url = CONFIG.firebaseUrl + "/snapshots.json?auth=" + CONFIG.firebaseSecret
            + "&orderBy=\"epoch\"&limitToLast=" + limit;
  const res  = UrlFetchApp.fetch(url, {muteHttpExceptions: true});
  return JSON.parse(res.getContentText());
}

// ============================================================
// @CanalQb — Módulo de Simulação de Rebalanceamento
// Calcula APR antes e depois de mover votos
// ============================================================

// ──── SIMULAR CENÁRIO DE REBALANCEAMENTO ────
// targetAllocation: [{srAddress, pct}] — % do total de votos
function simulateRebalance(currentPortfolio, targetAllocation, srData) {
  const totalVotes = currentPortfolio.reduce((s, p) => s + p.votes, 0);
  const currentAPR = calcPortfolioAPR(currentPortfolio);

  // Montar novo portfolio simulado
  const simPortfolio = targetAllocation.map(alloc => {
    const sr    = srData[alloc.srAddress] || {};
    const votes = Math.round(totalVotes * (alloc.pct / 100));
    return {
      name:         sr.name     || alloc.srAddress,
      address:      alloc.srAddress,
      votes:        votes,
      rank:         sr.rank         || 999,
      productivity: sr.productivity || 0,
      apr:          sr.apr          || 0,
      isActive:     (sr.rank || 999) <= CONFIG.rankThreshold,
      risk:         calcRisk(sr)
    };
  });

  const simAPR       = calcPortfolioAPR(simPortfolio);
  const aprDelta     = simAPR - currentAPR;
  const annualGain   = (aprDelta / 100) * totalVotes; // em TRX por ano
  const riskCurrent  = Math.round(currentPortfolio.reduce((s,p) => s+p.risk,0) / currentPortfolio.length);
  const riskSim      = Math.round(simPortfolio.reduce((s,p) => s+p.risk,0) / simPortfolio.length);

  const result = {
    currentAPR:    currentAPR,
    simulatedAPR:  simAPR,
    aprDelta:      aprDelta,
    annualGainTRX: annualGain,
    riskBefore:    riskCurrent,
    riskAfter:     riskSim,
    recommendation: aprDelta > 0.1 && riskSim <= riskCurrent ? "EXECUTAR"
                  : aprDelta > 0   && riskSim > riskCurrent  ? "AVALIAR (APR↑ mas Risco↑)"
                  : "NAO_RECOMENDADO"
  };

  // Registrar simulação no Sheets para análise
  logSimulationToSheet(result, simPortfolio);
  return result;
}

// ──── AUTO-SUGESTÃO DE REBALANCE (algoritmo de scoring) ────
function autoSuggestRebalance(portfolio, srData) {
  const suggestions = [];

  portfolio.forEach(p => {
    if (!p.isActive || p.risk >= 60) {
      // Encontrar alternativa de mesmo tier de votos mas melhor score
      const alternatives = Object.values(srData)
        .filter(sr => sr.isActive && sr.rank <= 20 && sr.productivity >= 99)
        .sort((a, b) => b.apr - a.apr)
        .slice(0, 3);

      suggestions.push({
        action:       "REALOCAR",
        from:         p.name,
        votes:        p.votes,
        fromRisk:     p.risk,
        alternatives: alternatives.map(a => ({
          name: a.name, rank: a.rank, apr: a.apr, risk: calcRisk(a)
        }))
      });
    }
  });

  return suggestions;
}

// ──── LOG DE SIMULAÇÃO NO SHEETS ────
function logSimulationToSheet(result, simPortfolio) {
  const ss    = SpreadsheetApp.getActiveSpreadsheet();
  const sheet = ss.getSheetByName("SIMULATION") || ss.insertSheet("SIMULATION");
  if (sheet.getLastRow() === 0) {
    sheet.appendRow(["Data","APR Atual","APR Sim","Delta","Ganho Anual TRX","Risco Antes","Risco Depois","Recomendação"]);
  }
  sheet.appendRow([
    new Date().toLocaleString("pt-BR"),
    result.currentAPR.toFixed(3),
    result.simulatedAPR.toFixed(3),
    result.aprDelta.toFixed(3),
    result.annualGainTRX.toFixed(0),
    result.riskBefore,
    result.riskAfter,
    result.recommendation
  ]);
}

// ============================================================
// @CanalQb — Módulo Multi-Canal de Alertas
// Discord Webhook + Email nativo GAS
// ============================================================

const DISCORD_WEBHOOK = "https://discord.com/api/webhooks/SEU_WEBHOOK_ID/SEU_TOKEN";
const ALERT_EMAIL     = "seu@email.com";

// ──── DISCORD WEBHOOK ────
function sendDiscord(alerts, apr) {
  const critical = alerts.some(a => a.severity === "CRITICO");
  const color    = critical ? 15158332 : 16776960; // vermelho ou amarelo

  const fields = alerts.map(a => ({
    name:   a.type + " [" + a.severity + "]",
    value:  a.sr ? "SR: " + a.sr : "APR: " + (a.curr||apr).toFixed(2) + "%",
    inline: true
  }));

  const payload = {
    embeds: [{
      title:       critical ? "🔴 TRON Monitor — Alerta Crítico" : "🟡 TRON Monitor — Aviso",
      description: "APR real da carteira: **" + apr.toFixed(2) + "%**",
      color:       color,
      fields:      fields,
      footer:      { text: "@CanalQb • canalqb.com.br" },
      timestamp:   new Date().toISOString()
    }]
  };

  UrlFetchApp.fetch(DISCORD_WEBHOOK, {
    method:      "post",
    contentType: "application/json",
    payload:     JSON.stringify(payload),
    muteHttpExceptions: true
  });
}

// ──── EMAIL NATIVO GAS (sem servidor externo) ────
function sendEmailAlert(alerts, apr) {
  if (alerts.length === 0) return;

  let html = "<h2>🚨 TRON Vote Monitor — @CanalQb</h2>";
  html += "<p><strong>APR atual: " + apr.toFixed(2) + "%</strong></p><ul>";
  alerts.forEach(a => {
    html += "<li>" + a.type + " — SR: " + (a.sr||"carteira") + " [" + a.severity + "]</li>";
  });
  html += "</ul><p><a href='https://canalqb.com.br'>canalqb.com.br</a></p>";

  GmailApp.sendEmail(ALERT_EMAIL, "[TRON Monitor] " + alerts.length + " alertas", "", {
    htmlBody: html,
    name: "@CanalQb TRON Monitor"
  });
}

// ──── ROTA UNIFICADA — chame esta ao invés das individuais ────
function notifyAll(alerts, apr) {
  if (alerts.length === 0) return;
  sendTelegram(formatAlertMsg(alerts, apr));  // do Core
  sendDiscord(alerts, apr);
  sendFCMPush(                                  // do Firebase module
    "TRON Monitor",
    alerts.length + " alertas detectados",
    { count: String(alerts.length) }
  );
  if (alerts.some(a => a.severity === "CRITICO")) {
    sendEmailAlert(alerts, apr);
  }
}