const express = require("express");
const puppeteer = require("puppeteer");
const fs = require("fs");
const path = require("path");
const cron = require("node-cron");
const https = require("https");
const http = require("http");

const app = express();
const PORT = 3070;

// 👉 Servir arquivos estáticos da pasta public
app.use(express.static(path.join(__dirname, "public")));

// Logos fixas de campeonatos
const logosFixas = {
    "champions": "https://api.thefullnet.site/logos/campeonatos/champions.png",
    "libertadores": "https://api.thefullnet.site/logos/campeonatos/libertadores.png",
    "uefa conference": "https://api.thefullnet.site/logos/campeonatos/uefa_conference_league.png",
    "leagues cup": "https://api.thefullnet.site/logos/campeonatos/leagues_cup.png",
    "sul-americana": "https://api.thefullnet.site/logos/campeonatos/copasulamericana.png",
    "sulamericana": "https://api.thefullnet.site/logos/campeonatos/copasulamericana.png",
    "central american cup": "https://api.thefullnet.site/logos/campeonatos/centralamericancup.png"
};

// Caminhos dos arquivos JSON
const fileHoje = "/www/wwwroot/lcan.thefullnet.com.br/jogos_final.json";
const fileAmanha = "/www/wwwroot/lcan.thefullnet.com.br/jogos_amanha.json";

// 🚨 Sempre aponta pro seu domínio
const PLACEHOLDER = "https://api.thefullnet.site/logos/placeholder.png";

function baixarLogo(url, nomeArquivo, tipo = "outros") {
    return new Promise((resolve, reject) => {
        if (!url) return resolve(null);

        const extensao = path.extname(url).split("?")[0] || ".png";
        const pastaDestino = path.join(__dirname, "public", "logos", tipo);
        if (!fs.existsSync(pastaDestino)) {
            fs.mkdirSync(pastaDestino, { recursive: true });
        }

        const destino = path.join(pastaDestino, nomeArquivo + extensao);

        // ✅ Se já existir, não baixa de novo
        if (fs.existsSync(destino)) {
            return resolve(`/logos/${tipo}/${nomeArquivo}${extensao}`);
        }

        const arquivo = fs.createWriteStream(destino);
        const protocolo = url.startsWith("https") ? https : http;

        protocolo.get(url, (res) => {
            if (res.statusCode === 200) {
                res.pipe(arquivo);
                arquivo.on("finish", () => {
                    arquivo.close();
                    resolve(`/logos/${tipo}/${nomeArquivo}${extensao}`);
                });
            } else {
                resolve(null);
            }
        }).on("error", (err) => reject(err));
    });
}

// Função para coletar logos de times, campeonato e canal dentro do link do jogo
async function pegarDetalhesDoJogo(link_jogo, browser) {
    try {
        const page = await browser.newPage();
        await page.goto(link_jogo, { waitUntil: "networkidle2" });

        const detalhes = await page.evaluate(() => {
            const baseUrl = "https://www.futebolnatv.com.br";

            const imgs = document.querySelectorAll("div.box_time img");
            const logosTimes = Array.from(imgs).map(img => img.src || img.getAttribute("data-src") || null);

            let logoCamp = document.querySelector("img.competition-flag, img[src*='/upload/countries/']")?.getAttribute("src") || "";
            if (logoCamp && !logoCamp.startsWith("http")) {
                logoCamp = baseUrl + logoCamp;
            }

            let imgCanal = document.querySelector("img[src*='/upload/channel/']")?.getAttribute("src") || "";
            if (imgCanal && !imgCanal.startsWith("http")) {
                imgCanal = baseUrl + imgCanal;
            }

            return { logosTimes, logoCampeonato: logoCamp, imgCanalUrl: imgCanal };
        });

        await page.close();
        return detalhes;
    } catch {
        return { logosTimes: [null, null], logoCampeonato: "", imgCanalUrl: "" };
    }
}

// 🚨 Força sempre logos no seu domínio
async function forcarLogoLocal(urlLogo, nomeArquivo, pasta) {
    if (!urlLogo || urlLogo.includes("loadteam.png")) return PLACEHOLDER;
    try {
        const caminhoLocal = await baixarLogo(urlLogo, nomeArquivo, pasta);
        if (caminhoLocal) {
            return `https://api.thefullnet.site${caminhoLocal}`;
        }
    } catch (e) {
        console.error("Erro ao baixar logo:", urlLogo, e.message);
    }
    return PLACEHOLDER;
}

async function coletarJogos(url, dia) {
    const browser = await puppeteer.launch({
        headless: true,
        args: ["--no-sandbox", "--disable-setuid-sandbox"]
    });

    const page = await browser.newPage();
    console.log(`Acessando site (${dia})...`);
    await page.goto(url, { waitUntil: "networkidle2" });

    let jogos = await page.evaluate((dia) => {
        const data = [];
        document.querySelectorAll(".gamecard").forEach(card => {
            const link = card.querySelector("a")?.href || "";
            const campeonatoInfo = card.querySelector(".col-sm-8")?.innerText.trim() || "";
            const horario = card.querySelector(".box_time")?.innerText.trim() || "";
            const transmissaoTxt = card.innerText.trim();
            const transmissaoFinal = transmissaoTxt.split("\n").pop().trim();

            const timeCasaEl = card.querySelectorAll(".d-flex")[0];
            const nomeCasa = timeCasaEl?.querySelector("img")?.getAttribute("title") || "";
            const golsCasa = timeCasaEl?.querySelectorAll("span")[1]?.innerText.trim() || "";

            const timeForaEl = card.querySelectorAll(".d-flex")[1];
            const nomeFora = timeForaEl?.querySelector("img")?.getAttribute("title") || "";
            const golsFora = timeForaEl?.querySelectorAll("span")[1]?.innerText.trim() || "";

            if (nomeCasa && nomeFora && campeonatoInfo && horario) {
                data.push({
                    data_jogo: dia,
                    campeonato: campeonatoInfo,
                    link_jogo: link,
                    logo_campeonato: "",
                    img_canal_url: "",
                    hora_jogo: horario,
                    transmissao: transmissaoFinal,
                    time_casa: nomeCasa,
                    imagem_casa: "",
                    gols_casa: golsCasa,
                    time_fora: nomeFora,
                    imagem_fora: "",
                    gols_fora: golsFora
                });
            }
        });
        return data;
    }, dia);

    for (let jogo of jogos) {
        const detalhes = await pegarDetalhesDoJogo(jogo.link_jogo, browser);

        jogo.imagem_casa = await forcarLogoLocal(
            detalhes.logosTimes?.[0],
            jogo.time_casa.replace(/\s+/g, "_"),
            "times"
        );

        jogo.imagem_fora = await forcarLogoLocal(
            detalhes.logosTimes?.[1],
            jogo.time_fora.replace(/\s+/g, "_"),
            "times"
        );

        const campNomeLower = jogo.campeonato.toLowerCase();
        let logoFixa = null;
        for (const chave of Object.keys(logosFixas)) {
            if (campNomeLower.includes(chave)) {
                logoFixa = logosFixas[chave];
                break;
            }
        }
        if (logoFixa) {
            jogo.logo_campeonato = logoFixa;
        } else {
            jogo.logo_campeonato = await forcarLogoLocal(
                detalhes.logoCampeonato,
                jogo.campeonato.replace(/\s+/g, "_"),
                "campeonatos"
            );
        }

        jogo.img_canal_url = await forcarLogoLocal(
            detalhes.imgCanalUrl,
            jogo.transmissao.replace(/\s+/g, "_"),
            "canais"
        );

        delete jogo.link_jogo;
    }

    await browser.close();

    const filePath = dia === "hoje" ? fileHoje : fileAmanha;
    if (jogos.length > 0) {
        fs.writeFileSync(filePath, JSON.stringify(jogos, null, 2), "utf-8");
        console.log(`✅ ${jogos.length} jogos salvos em ${filePath}`);
    } else {
        console.log(`⚠️ Nenhum jogo válido encontrado (${dia}), não sobrescrevi o JSON.`);
    }

    return jogos;
}

// Agendar todo dia às 06:00 da manhã
cron.schedule("0 6 * * *", async () => {
    console.log("⏰ Atualizando jogos automaticamente às 06:00...");
    try {
        await coletarJogos("https://www.futebolnatv.com.br/", "hoje");
        await coletarJogos("https://www.futebolnatv.com.br/jogos-amanha/", "amanha");
        console.log("✅ Atualização concluída!");
    } catch (err) {
        console.error("❌ Erro ao atualizar jogos:", err.message);
    }
}, {
    timezone: "America/Sao_Paulo"
});

// ==================
// 📌 Rotas 
// ==================

app.get("/atualizar-jogos", async (req, res) => {
    try {
        const jogos = await coletarJogos("https://www.futebolnatv.com.br/", "hoje");
        res.json({ sucesso: true, total: jogos.length });
    } catch (err) {
        console.error("Erro ao atualizar jogos de hoje:", err);
        res.status(500).json({ sucesso: false, erro: err.message });
    }
});

app.get("/atualizar-jogos-amanha", async (req, res) => {
    try {
        const jogos = await coletarJogos("https://www.futebolnatv.com.br/jogos-amanha/", "amanha");
        res.json({ sucesso: true, total: jogos.length });
    } catch (err) {
        console.error("Erro ao atualizar jogos de amanhã:", err);
        res.status(500).json({ sucesso: false, erro: err.message });
    }
});

app.get("/mostrar-jogos", (req, res) => {
    try {
        if (!fs.existsSync(fileHoje)) return res.json([]);
        let content = fs.readFileSync(fileHoje, "utf-8");
        content = content.replace(/^\uFEFF/, "").replace(/,\s*]/g, "]").replace(/,\s*}/g, "}");
        res.json(JSON.parse(content));
    } catch (err) {
        console.error("Erro ao mostrar jogos de hoje:", err);
        res.status(500).json({ sucesso: false, erro: err.message });
    }
});

app.get("/mostrar-jogos-amanha", (req, res) => {
    try {
        if (!fs.existsSync(fileAmanha)) return res.json([]);
        let content = fs.readFileSync(fileAmanha, "utf-8");
        content = content.replace(/^\uFEFF/, "").replace(/,\s*]/g, "]").replace(/,\s*}/g, "}");
        res.json(JSON.parse(content));
    } catch (err) {
        console.error("Erro ao mostrar jogos de amanhã:", err);
        res.status(500).json({ sucesso: false, erro: err.message });
    }
});

app.get("/campeonato/:nome", (req, res) => {
    try {
        const campeonatoNome = req.params.nome.toLowerCase();

        let jogosHoje = [];
        let jogosAmanha = [];

        if (fs.existsSync(fileHoje)) {
            let contentHoje = fs.readFileSync(fileHoje, "utf-8");
            contentHoje = contentHoje.replace(/^\uFEFF/, "").replace(/,\s*]/g, "]").replace(/,\s*}/g, "}");
            jogosHoje = JSON.parse(contentHoje);
        }

        if (fs.existsSync(fileAmanha)) {
            let contentAmanha = fs.readFileSync(fileAmanha, "utf-8");
            contentAmanha = contentAmanha.replace(/^\uFEFF/, "").replace(/,\s*]/g, "]").replace(/,\s*}/g, "}");
            jogosAmanha = JSON.parse(contentAmanha);
        }

        // Filtra os jogos que contenham o nome do campeonato (case insensitive)
        const filtrados = [...jogosHoje, ...jogosAmanha].filter(jogo =>
            jogo.campeonato.toLowerCase().includes(campeonatoNome)
        );

        res.json(filtrados);
    } catch (err) {
        console.error("Erro ao buscar jogos do campeonato:", err);
        res.status(500).json({ sucesso: false, erro: err.message });
    }
});

app.get("/time/:nome", (req, res) => {
    try {
        const nomeTime = req.params.nome.toLowerCase();

        let jogosHoje = [];
        let jogosAmanha = [];

        if (fs.existsSync(fileHoje)) {
            let contentHoje = fs.readFileSync(fileHoje, "utf-8");
            jogosHoje = JSON.parse(contentHoje);
        }

        if (fs.existsSync(fileAmanha)) {
            let contentAmanha = fs.readFileSync(fileAmanha, "utf-8");
            jogosAmanha = JSON.parse(contentAmanha);
        }

        // Filtra jogos onde o time aparece (casa ou fora)
        const filtrados = [...jogosHoje, ...jogosAmanha].filter(jogo =>
            jogo.time_casa.toLowerCase().includes(nomeTime) ||
            jogo.time_fora.toLowerCase().includes(nomeTime)
        );

        res.json(filtrados);
    } catch (err) {
        console.error("Erro ao buscar jogos do time:", err);
        res.status(500).json({ sucesso: false, erro: err.message });
    }
});

app.get("/canal/:nome", (req, res) => {
    try {
        const nomeCanal = req.params.nome.toLowerCase();

        let jogosHoje = [];
        let jogosAmanha = [];

        if (fs.existsSync(fileHoje)) {
            jogosHoje = JSON.parse(fs.readFileSync(fileHoje, "utf-8"));
        }

        if (fs.existsSync(fileAmanha)) {
            jogosAmanha = JSON.parse(fs.readFileSync(fileAmanha, "utf-8"));
        }

        // Filtra pelo campo de transmissão
        const filtrados = [...jogosHoje, ...jogosAmanha].filter(jogo =>
            jogo.transmissao.toLowerCase().includes(nomeCanal)
        );

        res.json(filtrados);
    } catch (err) {
        console.error("Erro ao buscar jogos do canal:", err);
        res.status(500).json({ sucesso: false, erro: err.message });
    }
});

app.get("/data/:dia", (req, res) => {
    try {
        const dia = req.params.dia;

        let jogos = [];

        if (fs.existsSync(fileHoje)) {
            jogos = JSON.parse(fs.readFileSync(fileHoje, "utf-8"));
        }
        if (fs.existsSync(fileAmanha)) {
            jogos = [...jogos, ...JSON.parse(fs.readFileSync(fileAmanha, "utf-8"))];
        }

        // Filtra pela data do jogo
        const filtrados = jogos.filter(jogo => jogo.data_jogo.includes(dia));

        res.json(filtrados);
    } catch (err) {
        console.error("Erro ao buscar jogos por data:", err);
        res.status(500).json({ sucesso: false, erro: err.message });
    }
});

app.get("/todos-os-jogos", (req, res) => {
    try {
        let jogos = [];

        if (fs.existsSync(fileHoje)) {
            jogos = [...jogos, ...JSON.parse(fs.readFileSync(fileHoje, "utf-8"))];
        }
        if (fs.existsSync(fileAmanha)) {
            jogos = [...jogos, ...JSON.parse(fs.readFileSync(fileAmanha, "utf-8"))];
        }

        res.json(jogos);
    } catch (err) {
        console.error("Erro ao listar todos os jogos:", err);
        res.status(500).json({ sucesso: false, erro: err.message });
    }
});

app.listen(PORT, () => {
    console.log(`🚀 Servidor Node rodando na porta ${PORT}`);
});
