index.js

const express = require('express');
const bodyParser = require('body-parser');
const axios = require('axios');
const cron = require('node-cron');
const fs = require('fs');
const path = require('path');
const WebSocket = require('ws');
const app = express();
app.use(bodyParser.json());

const configPath = path.join(__dirname, 'database.json');
const usersPath = path.join(__dirname, 'users.json');
const favoritesPath = path.join(__dirname, 'favorites.json');
const lastSeenPath = path.join(__dirname, 'lastSeen.json');

if (!fs.existsSync(configPath)) {
    fs.writeFileSync(configPath, JSON.stringify({
        PAGE_ACCESS_TOKEN: 'EAAJ2oq2jZCIwBO1kFcU7DaPM7vfGZC16ncAbJzFZAuokeSK5dEdpQ1muBKWZBC6sUDrDrG9Mq4thZCcH6pqFYM1viCDOIjmZCEGHRokhKj3kIAt5uTToHoZBZAkJSozb5mODsk5xxE8NXG3ZAtv7lcQneeHkiUJmwdmPQsFeuslWZAwfZC3Hvz4ZCa5yCwiDIcEJX0we28820E5GKKGuJfCKXRPRVUVsJAZDZD',
        VERIFY_TOKEN: 'ccprojects'
    }));
}

if (!fs.existsSync(usersPath)) fs.writeFileSync(usersPath, JSON.stringify({}));
if (!fs.existsSync(favoritesPath)) fs.writeFileSync(favoritesPath, JSON.stringify({}));
if (!fs.existsSync(lastSeenPath)) fs.writeFileSync(lastSeenPath, JSON.stringify({}));

const config = JSON.parse(fs.readFileSync(configPath));
const PAGE_ACCESS_TOKEN = config.PAGE_ACCESS_TOKEN;
const VERIFY_TOKEN = config.VERIFY_TOKEN;

const activeSessions = new Map();
const lastSentCache = new Map();
let sharedWebSocket = null;
let keepAliveInterval = null;
const PH_TIMEZONE = "Asia/Manila";

function pad(n) {
    return n < 10 ? "0" + n : n;
}

function getPHTime() {
    return new Date(new Date().toLocaleString("en-US", { timeZone: PH_TIMEZONE }));
}

function getCountdown(target) {
    const now = getPHTime();
    const msLeft = target - now;
    if (msLeft <= 0) return "00h 00m 00s";
    const h = Math.floor(msLeft / 3.6e6);
    const m = Math.floor((msLeft % 3.6e6) / 6e4);
    const s = Math.floor((msLeft % 6e4) / 1000);
    return `${pad(h)}h ${pad(m)}m ${pad(s)}s`;
}

function getNextRestocks() {
    const now = getPHTime();
    const timers = {};

    const nextEgg = new Date(now);
    nextEgg.setMinutes(now.getMinutes() < 30 ? 30 : 0);
    if (now.getMinutes() >= 30) nextEgg.setHours(now.getHours() + 1);
    nextEgg.setSeconds(0, 0);
    timers.egg = getCountdown(nextEgg);

    const next5 = new Date(now);
    const nextM = Math.ceil((now.getMinutes() + (now.getSeconds() > 0 ? 1 : 0)) / 5) * 5;
    next5.setMinutes(nextM === 60 ? 0 : nextM, 0, 0);
    if (nextM === 60) next5.setHours(now.getHours() + 1);
    timers.gear = timers.seed = getCountdown(next5);

    const nextHoney = new Date(now);
    nextHoney.setMinutes(now.getMinutes() < 30 ? 30 : 0);
    if (now.getMinutes() >= 30) nextHoney.setHours(now.getHours() + 1);
    nextHoney.setSeconds(0, 0);
    timers.honey = getCountdown(nextHoney);

    const next7 = new Date(now);
    const totalHours = now.getHours() + now.getMinutes() / 60 + now.getSeconds() / 3600;
    const next7h = Math.ceil(totalHours / 7) * 7;
    next7.setHours(next7h, 0, 0, 0);
    timers.cosmetics = getCountdown(next7);

    return timers;
}

function formatValue(val) {
    if (val >= 1_000_000) return `x${(val / 1_000_000).toFixed(1)}M`;
    if (val >= 1_000) return `x${(val / 1_000).toFixed(1)}K`;
    return `x${val}`;
}

function addEmoji(name) {
    const emojis = {
        "Common Egg": "🥚", "Uncommon Egg": "🐣", "Rare Egg": "🍳", "Legendary Egg": "🪺", "Mythical Egg": "🔮",
        "Bug Egg": "🪲", "Cleaning Spray": "🧴", "Friendship Pot": "🪴", "Watering Can": "🚿", "Trowel": "🛠️",
        "Recall Wrench": "🔧", "Basic Sprinkler": "💧", "Advanced Sprinkler": "💦", "Godly Sprinkler": "⛲",
        "Lightning Rod": "⚡", "Master Sprinkler": "🌊", "Favorite Tool": "❤️", "Harvest Tool": "🌾", "Carrot": "🥕",
        "Strawberry": "🍓", "Blueberry": "🫐", "Orange Tulip": "🌷", "Tomato": "🍅", "Corn": "🌽", "Daffodil": "🌼",
        "Watermelon": "🍉", "Pumpkin": "🎃", "Apple": "🍎", "Bamboo": "🎍", "Coconut": "🥥", "Cactus": "🌵",
        "Dragon Fruit": "🍈", "Mango": "🥭", "Grape": "🍇", "Mushroom": "🍄", "Pepper": "🌶️", "Cacao": "🍫",
        "Beanstalk": "🌱", "Ember Lily": "🏵️", "Sugar Apple": "🍏"
    };
    return `${emojis[name] || ""} ${name}`;
}

function getTimeAgo(date) {
    const now = getPHTime();
    const diff = now - new Date(date);
    const sec = Math.floor(diff / 1000);
    const min = Math.floor(sec / 60);
    const hour = Math.floor(min / 60);
    const day = Math.floor(hour / 24);

    if (sec < 60) return `${sec}s ago`;
    if (min < 60) return `${min}m ago`;
    if (hour < 24) return `${hour}h ago`;
    return `${day}d ago`;
}

function cleanText(text) {
    return text.trim().toLowerCase();
}

function loadFavorites() {
    try {
        return JSON.parse(fs.readFileSync(favoritesPath));
    } catch {
        return {};
    }
}

function saveFavorites(favorites) {
    fs.writeFileSync(favoritesPath, JSON.stringify(favorites));
}

function loadLastSeen() {
    try {
        return JSON.parse(fs.readFileSync(lastSeenPath));
    } catch {
        return {};
    }
}

function saveLastSeen(lastSeen) {
    fs.writeFileSync(lastSeenPath, JSON.stringify(lastSeen));
}

function updateLastSeen(category, items) {
    const lastSeen = loadLastSeen();
    if (!lastSeen[category]) lastSeen[category] = {};
    const now = new Date().toISOString();

    items.forEach(item => {
        lastSeen[category][item.name] = now;
    });

    saveLastSeen(lastSeen);
}

function ensureWebSocketConnection() {
    if (sharedWebSocket && sharedWebSocket.readyState === WebSocket.OPEN) return;

    sharedWebSocket = new WebSocket("wss://gagstock.gleeze.com");

    sharedWebSocket.on("open", () => {
        keepAliveInterval = setInterval(() => {
            if (sharedWebSocket.readyState === WebSocket.OPEN) {
                sharedWebSocket.send("ping");
            }
        }, 10000);
    });

    sharedWebSocket.on("message", async (data) => {
        try {
            const payload = JSON.parse(data);
            if (payload.status !== "success") return;

            const stock = payload.data;
            const stockData = {
                gear: stock.gear,
                seed: stock.seed,
                egg: stock.egg,
                cosmetics: stock.cosmetics,
                event: stock.honey,
            };

            updateLastSeen("gear", stockData.gear.items);
            updateLastSeen("seed", stockData.seed.items);
            updateLastSeen("egg", stockData.egg.items);
            updateLastSeen("cosmetics", stockData.cosmetics.items);
            updateLastSeen("event", stockData.event.items);

            const favorites = loadFavorites();

            for (const [senderId] of activeSessions.entries()) {
                const userFavorites = favorites[senderId] || [];
                let sections = [];
                let matchCount = 0;

                const checkAndAdd = (label, section, useEmoji) => {
                    const items = section.items || [];
                    const matchedItems = userFavorites.length > 0
                        ? items.filter(i => userFavorites.includes(cleanText(i.name)))
                        : items;
                    
                    if (userFavorites.length > 0 && matchedItems.length === 0) return false;
                    
                    matchCount += matchedItems.length;
                    const formattedItems = matchedItems.map(i => 
                        `- ${useEmoji ? addEmoji(i.name) : i.name}: ${formatValue(i.quantity)}`
                    ).join("\n");
                    
                    sections.push(`${label}:\n${formattedItems}\n⏳ Restock In: ${section.countdown}`);
                    return true;
                };

                checkAndAdd("🛠️ 𝗚𝗲𝗮𝗿", stockData.gear, true);
                checkAndAdd("🌱 𝗦𝗲𝗲𝗱𝘀", stockData.seed, true);
                checkAndAdd("🥚 𝗘𝗴𝗴𝘀", stockData.egg, true);
                checkAndAdd("🎨 𝗖𝗼𝘀𝗺𝗲𝘁𝗶𝗰𝘀", stockData.cosmetics, false);
                checkAndAdd("🎉 𝗘𝘃𝗲𝗻𝘁", stockData.event, false);

                if (userFavorites.length > 0 && matchCount === 0) continue;
                if (sections.length === 0) continue;

                const updatedAt = getPHTime().toLocaleString("en-PH", {
                    hour: "numeric", minute: "numeric", second: "numeric",
                    hour12: true, day: "2-digit", month: "short", year: "numeric"
                });

                const weather = await axios.get("https://growagardenstock.com/api/stock/weather")
                    .then(res => res.data)
                    .catch(() => null);
                
                const weatherInfo = weather
                    ? `🌤️ 𝗪𝗲𝗮𝘁𝗵𝗲𝗿: ${weather.icon} ${weather.weatherType}\n📋 ${weather.description}\n🎯 ${weather.cropBonuses}\n`
                    : "";

                const title = userFavorites.length > 0
                    ? `♥️ ${matchCount} 𝗙𝗮𝘃𝗼𝗿𝗶𝘁𝗲 𝗶𝘁𝗲𝗺${matchCount > 1 ? "s" : ""} 𝗙𝗼𝘂𝗻𝗱!`
                    : "🌾 𝗚𝗿𝗼𝘄 𝗔 𝗚𝗮𝗿𝗱𝗲𝗻 — 𝗧𝗿𝗮𝗰𝗸𝗲𝗿";

                const messageKey = JSON.stringify({ title, sections, weatherInfo, updatedAt });
                const lastSent = lastSentCache.get(senderId);
                if (lastSent === messageKey) continue;

                lastSentCache.set(senderId, messageKey);

                await sendMessage(senderId, 
                    `${title}\n\n${sections.join("\n\n")}\n\n${weatherInfo}📅 Updated at (PH): ${updatedAt}`
                );
            }
        } catch (error) {
            console.error('Error processing WebSocket message:', error);
        }
    });

    sharedWebSocket.on("close", () => {
        clearInterval(keepAliveInterval);
        sharedWebSocket = null;
        setTimeout(ensureWebSocketConnection, 3000);
    });

    sharedWebSocket.on("error", () => {
        sharedWebSocket?.close();
    });
}

async function sendTyping(recipientId) {
    try {
        await axios.post(`https://graph.facebook.com/v12.0/me/messages?access_token=${PAGE_ACCESS_TOKEN}`, {
            recipient: { id: recipientId },
            sender_action: 'typing_on'
        });
    } catch (error) {
        console.error('Error sending typing indicator:', error.message);
    }
}

async function getStockData() {
    try {
        const [stockResponse, updateResponse] = await Promise.all([
            axios.get('https://kenlie.top/api/gag/stocks/'),
            axios.get('https://jonell01-reuploadotherhruhh.hf.space/grow')
        ]);
        return {
            stockData: stockResponse.data,
            lastUpdated: updateResponse.data.lastUpdated
        };
    } catch (error) {
        console.error('Error fetching stock data:', error.message);
        return null;
    }
}

async function getWeatherData() {
    try {
        const response = await axios.get('https://kenlie.top/api/gag/weather/');
        return response.data;
    } catch (error) {
        console.error('Error fetching weather data:', error.message);
        return null;
    }
}

function formatStockMessage(data) {
    if (!data || !data.stockData.status) return "⚠️ Could not fetch stock data";
    
    let message = `🛒 𝗖𝗨𝗥𝗥𝗘𝗡𝗧 𝗦𝗧𝗢𝗖𝗞 𝗨𝗣𝗗𝗔𝗧𝗘𝗦 🛒\n`;
    message += `🕒 LAST UPDATED: ${new Date(data.lastUpdated).toLocaleString()}\n\n`;
    
    const stockData = data.stockData.response;
    const categories = {
        gearStock: '🛠️ 𝗚𝗘𝗔𝗥',
        eggStock: '🥚 𝗘𝗚𝗚𝗦',
        seedsStock: '🌱 𝗦𝗘𝗘𝗗𝗦',
        easterStock: '🐰 𝗘𝗔𝗦𝗧𝗘𝗥',
        nightStock: '🌙 𝗡𝗜𝗚𝗛𝗧',
        honeyStock: '🍯 𝗛𝗢𝗡𝗘𝗬',
        cosmeticsStock: '💄 𝗖𝗢𝗦𝗠𝗘𝗧𝗜𝗖𝗦 '
    };

    for (const [categoryKey, categoryName] of Object.entries(categories)) {
        if (stockData[categoryKey] && stockData[categoryKey].length > 0) {
            message += `${categoryName}:\n`;
            stockData[categoryKey].forEach(item => {
                message += `• ${item.name}: ${item.value}\n`;
            });
            message += '\n';
        }
    }
    return message;
}

function formatWeatherMessage(weatherData) {
    if (!weatherData || !weatherData.status) return "⚠️ Could not fetch weather data";
    
    const weatherEmojis = {
        rain: '🌧️ 𝗥𝗔𝗜𝗡',
        snow: '❄️ 𝗦𝗡𝗢𝗪',
        thunderstorm: '⚡ 𝗧𝗛𝗨𝗡𝗗𝗘𝗥𝗦𝗧𝗢𝗥𝗠',
        bloodnight: '🩸 𝗕𝗟𝗢𝗢𝗗𝗡𝗜𝗚𝗛𝗧',
        meteorshower: '☄️ 𝗠𝗘𝗧𝗘𝗢𝗥 𝗦𝗛𝗢𝗪𝗘𝗥',
        disco: '🪩 𝗗𝗜𝗦𝗖𝗢',
        jandelstorm: '🕯️ 𝗝𝗔𝗡𝗗𝗘𝗟𝗦𝗧𝗢𝗥𝗠',
        blackhole: '🕳️ 𝗕𝗟𝗔𝗖𝗞𝗛𝗢𝗟𝗘',
        frost: '❄️ 𝗙𝗥𝗢𝗦𝗧 '
    };
    
    let message = '⛅ 𝗖𝗨𝗥𝗥𝗘𝗡𝗧 𝗪𝗘𝗔𝗧𝗛𝗘𝗥 𝗖𝗢𝗡𝗗𝗜𝗧𝗜𝗢𝗡𝗦\n\n';
    const activeEvents = [];
    
    for (const [event, data] of Object.entries(weatherData.response)) {
        if (data.active) {
            activeEvents.push(`${weatherEmojis[event] || '🌀'} ${event.toUpperCase()}`);
        }
    }
    
    if (activeEvents.length === 0) {
        message += "☀️ NO ACTIVE WEATHER EVENTS\n";
    } else {
        message += "🟢 𝗔𝗖𝗧𝗜𝗩𝗘 𝗪𝗘𝗔𝗧𝗛𝗘𝗥 𝗘𝗩𝗘𝗡𝗧𝗦:\n";
        message += activeEvents.join('\n');
    }
    
    return message;
}

async function sendMessage(recipientId, messageText) {
    try {
        await axios.post(`https://graph.facebook.com/v12.0/me/messages?access_token=${PAGE_ACCESS_TOKEN}`, {
            recipient: { id: recipientId },
            message: { text: messageText }
        });
    } catch (error) {
        console.error('Error sending message:', error.message);
    }
}

function loadUserPreferences() {
    try {
        return JSON.parse(fs.readFileSync(usersPath));
    } catch {
        return {};
    }
}

function saveUserPreferences(preferences) {
    fs.writeFileSync(usersPath, JSON.stringify(preferences));
}

function setupUserNotification(recipientId, intervalMinutes = 5) {
    const preferences = loadUserPreferences();
    if (preferences[recipientId]?.intervalId) {
        clearInterval(preferences[recipientId].intervalId);
    }

    const intervalId = setInterval(async () => {
        const data = await getStockData();
        if (data) {
            await sendMessage(recipientId, formatStockMessage(data));
        }
    }, intervalMinutes * 60 * 1000);

    preferences[recipientId] = {
        notificationsOn: true,
        interval: intervalMinutes,
        intervalId: intervalId
    };
    saveUserPreferences(preferences);
}

function turnOffNotifications(recipientId) {
    const preferences = loadUserPreferences();
    if (preferences[recipientId]?.intervalId) {
        clearInterval(preferences[recipientId].intervalId);
    }
    preferences[recipientId] = {
        notificationsOn: false,
        interval: null,
        intervalId: null
    };
    saveUserPreferences(preferences);
}

async function handleGagStockCommand(senderId, args) {
    const subcmd = args[0]?.toLowerCase();

    if (subcmd === "fav") {
        const action = args[1]?.toLowerCase();
        const input = args.slice(2).join(" ").split("|").map(i => cleanText(i)).filter(Boolean);
        
        if (!action || !["add", "remove"].includes(action) || input.length === 0) {
            return await sendMessage(senderId, "📌 Usage: /gagstock fav add/remove Item1 | Item2");
        }

        const favorites = loadFavorites();
        const userFavorites = favorites[senderId] || [];
        const updated = new Set(userFavorites);

        for (const name of input) {
            if (action === "add") updated.add(name);
            else if (action === "remove") updated.delete(name);
        }

        favorites[senderId] = Array.from(updated);
        saveFavorites(favorites);
        return await sendMessage(senderId, `✅ Favorite list updated: ${Array.from(updated).join(", ") || "(empty)"}`);
    }

    if (subcmd === "lastseen") {
        const filters = args.slice(1).join(" ").split("|").map(c => c.trim().toLowerCase()).filter(Boolean);
        const categories = filters.length > 0 ? filters : ["gear", "seed", "egg", "cosmetics", "event"];
        const lastSeen = loadLastSeen();

        let result = [];
        for (const cat of categories) {
            const entries = lastSeen[cat];
            if (!entries || Object.keys(entries).length === 0) continue;

            const list = Object.entries(entries)
                .sort((a, b) => new Date(b[1]) - new Date(a[1]))
                .map(([name, date]) => `• ${name}: ${getTimeAgo(date)}`);

            result.push(`🔹 ${cat.toUpperCase()} (${list.length})\n${list.join("\n")}`);
        }

        if (result.length === 0) {
            return await sendMessage(senderId, "⚠️ No last seen data found for the selected category.");
        }

        return await sendMessage(senderId, `📦 𝗟𝗮𝘀𝘁 𝗦𝗲𝗲𝗻 𝗜𝘁𝗲𝗺𝘀\n\n${result.join("\n\n")}`);
    }

    if (subcmd === "off") {
        if (!activeSessions.has(senderId)) {
            return await sendMessage(senderId, "⚠️ You don't have an active gagstock session.");
        }
        activeSessions.delete(senderId);
        lastSentCache.delete(senderId);
        return await sendMessage(senderId, "🛑 Gagstock tracking stopped.");
    }

    if (subcmd !== "on") {
        return await sendMessage(senderId,
            "📌 Usage:\n• /gagstock on\n• /gagstock fav add Carrot | Watering Can\n• /gagstock lastseen gear | seed\n• /gagstock off"
        );
    }

    if (activeSessions.has(senderId)) {
        return await sendMessage(senderId, "📡 You're already tracking Gagstock. Use /gagstock off to stop.");
    }

    activeSessions.set(senderId, true);
    await sendMessage(senderId, "✅ Gagstock tracking started via WebSocket!");
    ensureWebSocketConnection();
}

app.get('/webhook', (req, res) => {
    if (req.query['hub.mode'] === 'subscribe' && req.query['hub.verify_token'] === VERIFY_TOKEN) {
        res.status(200).send(req.query['hub.challenge']);
    } else {
        res.sendStatus(403);
    }
});

app.post('/webhook', async (req, res) => {
    if (req.body.object === 'page') {
        for (const entry of req.body.entry) {
            for (const event of entry.messaging) {
                if (event.message?.text) {
                    await handleMessage(event.sender.id, event.message.text);
                }
            }
        }
        res.status(200).send('EVENT_RECEIVED');
    } else {
        res.sendStatus(404);
    }
});

async function handleMessage(senderId, messageText) {
    const command = messageText.trim().toLowerCase();
    
    await sendTyping(senderId);

    if (command === '/help') {
        const helpMessage = `🌱 𝗚𝗥𝗢𝗪 𝗔 𝗚𝗔𝗥𝗗𝗘𝗡 𝗕𝗢𝗧 𝗛𝗘𝗟𝗣 🌱\n\n` +
            `🛒 /𝘀𝘁𝗼𝗰𝗸 - Get current stock information\n` +
            `⛅ /𝘄𝗲𝗮𝘁𝗵𝗲𝗿 - Get current weather conditions\n` +
            `🌾 /𝗴𝗮𝗴𝘀𝘁𝗼𝗰𝗸 - Real-time stock tracking\n` +
            `  • /𝗴𝗮𝗴𝘀𝘁𝗼𝗰𝗸 𝗼𝗻 - Start tracking\n` +
            `  • /𝗴𝗮𝗴𝘀𝘁𝗼𝗰𝗸 𝗼𝗳𝗳 - Stop tracking\n` +
            `  • /𝗴𝗮𝗴𝘀𝘁𝗼𝗰𝗸 𝗳𝗮𝘃 𝗮𝗱𝗱 𝗶𝘁𝗲𝗺 - Add favorite\n` +
            `  • /𝗴𝗮𝗴𝘀𝘁𝗼𝗰𝗸 𝗹𝗮𝘀𝘁𝘀𝗲𝗲𝗻 - View last seen items\n` +
            `🔔 /𝗻𝗼𝘁𝗶 𝗼𝗻 - Enable stock notifications\n` +
            `🔕 /𝗻𝗼𝘁𝗶 𝗼𝗳𝗳 - Disable notifications\n` +
            `⏱️ /𝗻𝗼𝘁𝗶 𝗼𝗻 [𝗺𝗶𝗻𝘂𝘁𝗲𝘀] - Set notification interval\n` +
            `ℹ️ /𝗵𝗲𝗹𝗽 - Show this help message`;
        await sendMessage(senderId, helpMessage);
    }
    else if (command === '/stock') {
        const data = await getStockData();
        await sendMessage(senderId, data ? formatStockMessage(data) : '⚠️ Could not fetch stock data');
    }
    else if (command === '/weather') {
        const weatherData = await getWeatherData();
        await sendMessage(senderId, weatherData ? formatWeatherMessage(weatherData) : '⚠️ Could not fetch weather data');
    }
    else if (command.startsWith('/gagstock')) {
        const args = command.split(' ').slice(1);
        await handleGagStockCommand(senderId, args);
    }
    else if (command.startsWith('/noti')) {
        const parts = command.split(' ');
        if (parts[1] === 'on') {
            const interval = parts[2] ? parseInt(parts[2]) : 5;
            if (isNaN(interval) || interval < 1) {
                await sendMessage(senderId, '⚠️ Please provide valid minutes (e.g., /noti on 5)');
                return;
            }
            setupUserNotification(senderId, interval);
            await sendMessage(senderId, `🔔 Notifications enabled! Updates every ${interval} minutes.`);
        } 
        else if (parts[1] === 'off') {
            turnOffNotifications(senderId);
            await sendMessage(senderId, '🔕 Notifications disabled!');
        } 
        else {
            await sendMessage(senderId, '⚠️ Use /noti on, /noti off, or /noti on [minutes]');
        }
    }
    else {
        await sendMessage(senderId, '🌿 Welcome! Grow a Garden Notifier Stocks User! Type /help for commands.');
    }
}

loadUserPreferences();
const PORT = process.env.PORT || 7860;
app.listen(PORT, () => {
    console.log(`Bot running on port ${PORT}`);
});