index.js

const express = require('express');
const cors = require('cors');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const db = require('./db');
const dotenv = require('dotenv');

dotenv.config();

const app = express();
const PORT = process.env.PORT || 5000;
const JWT_SECRET = process.env.JWT_SECRET || 'your_jwt_secret_key_change_this';

app.use(cors());
app.use(express.json());

// Initialize axios and cache for CoinGecko API calls
const axios = require('axios');
const NodeCache = require('node-cache');
const myCache = new NodeCache({ stdTTL: 300 }); // Cache for 5 minutes
let apiHitsToday = 0;

// Unique visitor tracking (Set of IPs, resets daily at midnight EST)
let visitorsToday = new Set();

// Timezone handling for EST midnight reset
const moment = require('moment-timezone');

// Helper function to get today's date in EST timezone (YYYY-MM-DD format)
const getTodayDateEST = () => {
    return moment().tz('America/New_York').format('YYYY-MM-DD');
};

// Helper function to get next midnight EST as a Date object
const getNextMidnightEST = () => {
    const now = moment().tz('America/New_York');
    const nextMidnight = now.clone().add(1, 'day').startOf('day');
    return nextMidnight.toDate();
};

// Helper function to get milliseconds until next midnight EST
const getMsUntilMidnightEST = () => {
    const now = moment().tz('America/New_York');
    const nextMidnight = now.clone().add(1, 'day').startOf('day');
    return nextMidnight.diff(now);
};

// Schedule a reset of daily counters at the next midnight EST, then every 24h after that
const scheduleMidnightReset = () => {
    const msUntilMidnight = getMsUntilMidnightEST();
    setTimeout(() => {
        apiHitsToday = 0;
        visitorsToday = new Set();
        // Schedule again for the following midnight
        setInterval(() => {
            apiHitsToday = 0;
            visitorsToday = new Set();
        }, 24 * 60 * 60 * 1000);
    }, msUntilMidnight);
};
scheduleMidnightReset();

// Middleware: track unique visitors by IP
app.use((req, res, next) => {
    const ip = req.headers['x-forwarded-for']?.split(',')[0].trim() || req.socket.remoteAddress || 'unknown';
    visitorsToday.add(ip);
    next();
});

// Middleware to verify JWT token
const authenticateToken = (req, res, next) => {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];

    if (!token) return res.sendStatus(401);

    jwt.verify(token, JWT_SECRET, (err, user) => {
        if (err) return res.sendStatus(403);
        req.user = user;
        next();
    });
};

// Middleware to verify super admin password
const SUPER_ADMIN_PASSWORD = process.env.SUPER_ADMIN_PASSWORD || 'cryptocardiac_super_admin_2026';
const authenticateSuperAdmin = (req, res, next) => {
    const password = req.headers['x-admin-password'];
    if (!password || password !== SUPER_ADMIN_PASSWORD) {
        return res.status(403).json({ error: 'Forbidden: Super admin access required' });
    }
    next();
};

// --- Auth Routes ---

// Signup
app.post('/api/auth/signup', async (req, res) => {
    const { email, password, captchaToken } = req.body;
    const TURNSTILE_SECRET_KEY = process.env.TURNSTILE_SECRET_KEY || '1x0000000000000000000000000000000AA'; // Secret Key

    if (!email || !password) {
        return res.status(400).json({ error: 'Email and password are required' });
    }

    if (!captchaToken) {
        return res.status(400).json({ error: 'CAPTCHA verification failed' });
    }

    try {
        // Verify Turnstile Token
        const verifyResponse = await axios.post('https://challenges.cloudflare.com/turnstile/v0/siteverify', {
            secret: TURNSTILE_SECRET_KEY,
            response: captchaToken
        });

        if (!verifyResponse.data.success) {
            return res.status(400).json({ error: 'CAPTCHA verification failed. Please try again.' });
        }

        // Check if user exists
        const [existingUsers] = await db.query('SELECT * FROM users WHERE email = ?', [email]);
        if (existingUsers.length > 0) {
            return res.status(400).json({ error: 'User already exists' });
        }

        // Hash password
        const salt = await bcrypt.genSalt(10);
        const hashedPassword = await bcrypt.hash(password, salt);

        // Insert user
        const [result] = await db.query('INSERT INTO users (email, password_hash) VALUES (?, ?)', [email, hashedPassword]);

        // Create token
        const token = jwt.sign({ id: result.insertId, email }, JWT_SECRET, { expiresIn: '24h' });

        res.status(201).json({
            token,
            user: {
                id: result.insertId,
                email,
                share_points: 0
            }
        });
    } catch (error) {
        console.error('Signup error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Login
app.post('/api/auth/login', async (req, res) => {
    const { email, password } = req.body;

    try {
        const [users] = await db.query('SELECT * FROM users WHERE email = ?', [email]);
        if (users.length === 0) {
            return res.status(400).json({ error: 'Invalid credentials' });
        }

        const user = users[0];
        const isMatch = await bcrypt.compare(password, user.password_hash);

        if (!isMatch) {
            return res.status(400).json({ error: 'Invalid credentials' });
        }

        const token = jwt.sign({ id: user.id, email: user.email }, JWT_SECRET, { expiresIn: '24h' });

        res.json({
            token,
            user: {
                id: user.id,
                email: user.email,
                share_points: user.share_points
            }
        });
    } catch (error) {
        console.error('Login error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Get Current User (Verify Token)
app.get('/api/auth/me', authenticateToken, async (req, res) => {
    try {
        const [users] = await db.query('SELECT id, email, share_points FROM users WHERE id = ?', [req.user.id]);
        if (users.length === 0) return res.sendStatus(404);

        res.json({ user: users[0] });
    } catch (error) {
        console.error('Get me error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// --- Voting Routes ---

// Get all vote counts
// Get all vote counts (Votes + Shares)
app.get('/api/votes', async (req, res) => {
    try {
        // Get regular votes
        const [voteRows] = await db.query('SELECT coin_id, COUNT(*) as count FROM votes GROUP BY coin_id');

        // Get share logs (these now count as votes for the coin)
        const [shareRows] = await db.query('SELECT coin_id, COUNT(*) as count FROM share_logs GROUP BY coin_id');

        const votes = {};

        // Add regular votes
        voteRows.forEach(row => {
            votes[row.coin_id] = (votes[row.coin_id] || 0) + row.count;
        });

        // Add share votes
        shareRows.forEach(row => {
            votes[row.coin_id] = (votes[row.coin_id] || 0) + row.count;
        });

        res.json(votes);
    } catch (error) {
        console.error('Get votes error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Get time-based vote counts (24h, 7d, 3 months)
// 24h = Today's votes (resets at midnight EST)
// 7d = Last 7 days (rolling window)
// 3m = Last 90 days (rolling window)
app.get('/api/votes/time-based', async (req, res) => {
    try {
        const todayEST = getTodayDateEST(); // Get today's date in EST (YYYY-MM-DD)

        // Count for 24h (Today)
        const [votes24h] = await db.query(`
            SELECT coin_id, COUNT(*) as count 
            FROM (
                SELECT coin_id FROM votes WHERE DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?
                UNION ALL
                SELECT coin_id FROM share_logs WHERE DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?
            ) as combined
            GROUP BY coin_id
        `, [todayEST, todayEST]);

        // Count for 7d
        const [votes7d] = await db.query(`
            SELECT coin_id, COUNT(*) as count 
            FROM (
                SELECT coin_id FROM votes WHERE created_at >= NOW() - INTERVAL 7 DAY
                UNION ALL
                SELECT coin_id FROM share_logs WHERE created_at >= NOW() - INTERVAL 7 DAY
            ) as combined
            GROUP BY coin_id
        `);

        // Count for 3m
        const [votes3m] = await db.query(`
            SELECT coin_id, COUNT(*) as count 
            FROM (
                SELECT coin_id FROM votes WHERE created_at >= NOW() - INTERVAL 90 DAY
                UNION ALL
                SELECT coin_id FROM share_logs WHERE created_at >= NOW() - INTERVAL 90 DAY
            ) as combined
            GROUP BY coin_id
        `);

        // Combine all results into a single object
        const timeBasedVotes = {};

        const addCount = (coinId, type, count) => {
            if (!timeBasedVotes[coinId]) {
                timeBasedVotes[coinId] = { votes_24h: 0, votes_7d: 0, votes_3m: 0 };
            }
            timeBasedVotes[coinId][type] = count;
        };

        votes24h.forEach(row => addCount(row.coin_id, 'votes_24h', row.count));
        votes7d.forEach(row => addCount(row.coin_id, 'votes_7d', row.count));
        votes3m.forEach(row => addCount(row.coin_id, 'votes_3m', row.count));

        res.json(timeBasedVotes);
    } catch (error) {
        console.error('Get time-based votes error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Get most consistent communities (streak calculation)
app.get('/api/votes/consistent', async (req, res) => {
    try {
        const todayEST = getTodayDateEST();

        // 1. Get all dates where votes occurred, grouped by coin
        // We order by date DESC to easily check streaks
        // Use MAX(coin_name) to comply with ONLY_FULL_GROUP_BY
        const [rows] = await db.query(`
            SELECT coin_id, MAX(coin_name) as coin_name, DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) as vote_date 
            FROM votes 
            GROUP BY coin_id, vote_date 
            ORDER BY coin_id, vote_date DESC
        `);

        if (rows.length === 0) {
            return res.json([]);
        }

        // 2. Process streaks in memory
        const streaks = {}; // { coinId: { streak: number, name: string, lastDate: string } }

        rows.forEach(row => {
            const coinId = row.coin_id;
            const voteDate = moment(row.vote_date).format('YYYY-MM-DD');

            if (!streaks[coinId]) {
                streaks[coinId] = {
                    coinId: coinId,
                    coinName: row.coin_name,
                    streak: 0,
                    dates: []
                };
            }
            streaks[coinId].dates.push(voteDate);
        });

        const consistentCoins = [];
        const today = moment(todayEST);
        const yesterday = moment(todayEST).subtract(1, 'days');

        Object.values(streaks).forEach(coin => {
            let currentStreak = 0;
            const dates = new Set(coin.dates); // Unique dates already ensured by SQL GROUP BY but safe to be sure

            // Check if they have a vote today OR yesterday to keep streak alive
            const hasVoteToday = dates.has(today.format('YYYY-MM-DD'));
            const hasVoteYesterday = dates.has(yesterday.format('YYYY-MM-DD'));

            if (!hasVoteToday && !hasVoteYesterday) {
                // Streak broken if no vote today AND no vote yesterday
                currentStreak = 0;
            } else {
                // Calculate streak walking backwards
                // If they voted today, start checking from today
                // If they didn't vote today but did yesterday, start checking from yesterday
                let checkDate = hasVoteToday ? today.clone() : yesterday.clone();

                while (dates.has(checkDate.format('YYYY-MM-DD'))) {
                    currentStreak++;
                    checkDate.subtract(1, 'days');
                }
            }

            if (currentStreak > 0) {
                consistentCoins.push({
                    coinId: coin.coinId,
                    coinName: coin.coinName,
                    streak: currentStreak
                });
            }
        });

        // 3. Sort by streak DESC
        consistentCoins.sort((a, b) => b.streak - a.streak);

        // 4. Top 10 only
        const topConsistent = consistentCoins.slice(0, 10);

        // 5. Fetch images/symbols for these coins
        const coinIds = topConsistent.map(c => c.coinId).join(',');

        if (coinIds) {
            const cacheKey = `details_${coinIds}_usd`; // Reuse existing cache pattern if possible or make new
            // We can just use the existing helper logic or call the API directly if helper not exposed well
            // Let's call API via axios if not in cache (simplified)
            // Or better, reuse the existing CoinGecko logic pattern
            try {
                let coinDetails = myCache.get(cacheKey);
                if (!coinDetails) {
                    apiHitsToday++;
                    const response = await axios.get('https://api.coingecko.com/api/v3/coins/markets', {
                        params: {
                            vs_currency: 'usd',
                            ids: coinIds,
                            order: 'market_cap_desc',
                            sparkline: false
                        }
                    });
                    coinDetails = response.data;
                    myCache.set(cacheKey, coinDetails);
                }

                // Merge details
                const detailsMap = {};
                coinDetails.forEach(c => detailsMap[c.id] = c);

                topConsistent.forEach(c => {
                    const details = detailsMap[c.coinId];
                    if (details) {
                        c.image = details.image;
                        c.symbol = details.symbol;
                    }
                });

            } catch (err) {
                console.error('Error fetching details for consistent coins:', err.message);
            }
        }

        res.json(topConsistent);

    } catch (error) {
        console.error('Get consistent communities error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Check user's per-coin voting status
app.get('/api/votes/status', authenticateToken, async (req, res) => {
    const userId = req.user.id;

    try {
        const todayEST = getTodayDateEST();

        // Get all votes by this user today (EST)
        const [rows] = await db.query(
            `SELECT coin_id, created_at FROM votes 
             WHERE user_id = ? 
             AND DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?`,
            [userId, todayEST]
        );

        console.log(`Checking status for user ${userId}. Found ${rows.length} votes today (EST).`);

        // Return list of coins the user has voted for today
        const votedCoins = rows.map(row => ({
            coinId: row.coin_id,
            votedAt: row.created_at
        }));

        res.json({ votedCoins });
    } catch (error) {
        console.error('Check vote status error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Check if user can vote for a specific coin (daily reset at midnight EST)
app.get('/api/votes/check/:coinId', authenticateToken, async (req, res) => {
    const userId = req.user.id;
    const { coinId } = req.params;

    try {
        const todayEST = getTodayDateEST();

        // Check for vote on THIS specific coin today (EST)
        const [rows] = await db.query(
            `SELECT created_at FROM votes 
             WHERE user_id = ? AND coin_id = ? 
             AND DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?`,
            [userId, coinId, todayEST]
        );

        if (rows.length > 0) {
            const remainingMs = getMsUntilMidnightEST();

            return res.json({
                canVote: false,
                remainingMs,
                lastVoteTime: rows[0].created_at
            });
        }

        res.json({ canVote: true });
    } catch (error) {
        console.error('Check vote status error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Cast a vote
app.post('/api/votes', authenticateToken, async (req, res) => {
    const { coinId, coinName } = req.body;
    const userId = req.user.id;

    try {
        const todayEST = getTodayDateEST();

        // Check restriction for THIS specific coin (per-coin, per-day restriction)
        const [rows] = await db.query(
            `SELECT created_at FROM votes 
             WHERE user_id = ? AND coin_id = ? 
             AND DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?`,
            [userId, coinId, todayEST]
        );

        if (rows.length > 0) {
            const remainingMs = getMsUntilMidnightEST();
            const remainingHours = Math.floor(remainingMs / (1000 * 60 * 60));
            const remainingMinutes = Math.floor((remainingMs % (1000 * 60 * 60)) / (1000 * 60));

            return res.status(400).json({
                error: `You already voted for ${coinName} today. You can vote again at midnight EST (in ${remainingHours}h ${remainingMinutes}m).`
            });
        }

        // Start transaction
        await db.query('START TRANSACTION');

        try {
            await db.query(
                'INSERT INTO votes (user_id, coin_id, coin_name) VALUES (?, ?, ?)',
                [userId, coinId, coinName]
            );

            // Increment user points for voting
            await db.query('UPDATE users SET share_points = COALESCE(share_points, 0) + 1 WHERE id = ?', [userId]);

            // Commit transaction
            await db.query('COMMIT');

            // Get updated points
            const [users] = await db.query('SELECT share_points FROM users WHERE id = ?', [userId]);
            const newPoints = users[0].share_points;

            res.json({ message: 'Vote cast successfully', share_points: newPoints });

        } catch (err) {
            await db.query('ROLLBACK');
            throw err;
        }
    } catch (error) {
        console.error('Cast vote error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Increment share points (with daily limit per coin)
app.post('/api/share/x', authenticateToken, async (req, res) => {
    const userId = req.user.id;
    const { coinId, coinName } = req.body;

    if (!coinId) {
        return res.status(400).json({ error: 'Coin ID is required' });
    }

    try {
        const todayEST = getTodayDateEST();

        // Check if user has already shared this coin today (EST)
        const [rows] = await db.query(
            `SELECT created_at FROM share_logs 
             WHERE user_id = ? AND coin_id = ? 
             AND DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?`,
            [userId, coinId, todayEST]
        );

        if (rows.length > 0) {
            return res.status(400).json({ error: 'You have already received points for sharing this coin today.' });
        }

        // Start transaction
        await db.query('START TRANSACTION');

        try {
            // Insert into share_logs
            await db.query(
                'INSERT INTO share_logs (user_id, coin_id) VALUES (?, ?)',
                [userId, coinId]
            );

            // Increment user points (sharing does NOT count as a vote)
            await db.query('UPDATE users SET share_points = COALESCE(share_points, 0) + 1 WHERE id = ?', [userId]);

            // Commit transaction
            await db.query('COMMIT');

            const [users] = await db.query('SELECT share_points FROM users WHERE id = ?', [userId]);
            const newPoints = users[0].share_points;

            res.json({ message: 'Share points updated', share_points: newPoints });
        } catch (err) {
            await db.query('ROLLBACK');
            throw err;
        }
    } catch (error) {
        console.error('Share points error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Increment share points for Discord (with daily limit per coin)
app.post('/api/share/discord', authenticateToken, async (req, res) => {
    const userId = req.user.id;
    const { coinId, coinName } = req.body;

    if (!coinId) {
        return res.status(400).json({ error: 'Coin ID is required' });
    }

    try {
        const todayEST = getTodayDateEST();

        // Check if user has already shared this coin today (EST)
        const [rows] = await db.query(
            `SELECT created_at FROM share_logs 
             WHERE user_id = ? AND coin_id = ? 
             AND DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?`,
            [userId, coinId, todayEST]
        );

        if (rows.length > 0) {
            return res.status(400).json({ error: 'You have already received points for sharing this coin today.' });
        }

        // Start transaction
        await db.query('START TRANSACTION');

        try {
            // Insert into share_logs
            await db.query(
                'INSERT INTO share_logs (user_id, coin_id) VALUES (?, ?)',
                [userId, coinId]
            );

            // Increment user points (sharing does NOT count as a vote)
            await db.query('UPDATE users SET share_points = COALESCE(share_points, 0) + 1 WHERE id = ?', [userId]);

            // Commit transaction
            await db.query('COMMIT');

            const [users] = await db.query('SELECT share_points FROM users WHERE id = ?', [userId]);
            const newPoints = users[0].share_points;

            res.json({ message: 'Share points updated', share_points: newPoints });
        } catch (err) {
            await db.query('ROLLBACK');
            throw err;
        }
    } catch (error) {
        console.error('Share points error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Increment share points for Reddit (with daily limit per coin)
app.post('/api/share/reddit', authenticateToken, async (req, res) => {
    const userId = req.user.id;
    const { coinId, coinName } = req.body;

    if (!coinId) {
        return res.status(400).json({ error: 'Coin ID is required' });
    }

    try {
        const todayEST = getTodayDateEST();

        // Check if user has already shared this coin today (EST)
        const [rows] = await db.query(
            `SELECT created_at FROM share_logs 
             WHERE user_id = ? AND coin_id = ? 
             AND DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?`,
            [userId, coinId, todayEST]
        );

        if (rows.length > 0) {
            return res.status(400).json({ error: 'You have already received points for sharing this coin today.' });
        }

        // Start transaction
        await db.query('START TRANSACTION');

        try {
            // Insert into share_logs
            await db.query(
                'INSERT INTO share_logs (user_id, coin_id) VALUES (?, ?)',
                [userId, coinId]
            );

            // Increment user points (sharing does NOT count as a vote)
            await db.query('UPDATE users SET share_points = COALESCE(share_points, 0) + 1 WHERE id = ?', [userId]);

            // Commit transaction
            await db.query('COMMIT');

            const [users] = await db.query('SELECT share_points FROM users WHERE id = ?', [userId]);
            const newPoints = users[0].share_points;

            res.json({ message: 'Share points updated', share_points: newPoints });
        } catch (err) {
            await db.query('ROLLBACK');
            throw err;
        }
    } catch (error) {
        console.error('Share points error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Get user's complete voting history with coin details
app.get('/api/votes/history', authenticateToken, async (req, res) => {
    const userId = req.user.id;

    try {
        // Get only the MOST RECENT vote per coin (no duplicates)
        const [votes] = await db.query(
            `SELECT v.coin_id, v.coin_name, v.created_at 
             FROM votes v
             INNER JOIN (
                 SELECT coin_id, MAX(created_at) as max_created_at
                 FROM votes
                 WHERE user_id = ?
                 GROUP BY coin_id
             ) latest ON v.coin_id = latest.coin_id AND v.created_at = latest.max_created_at
             WHERE v.user_id = ?
             ORDER BY v.created_at DESC`,
            [userId, userId]
        );

        if (votes.length === 0) {
            return res.json({ votes: [] });
        }

        // Get unique coin IDs
        const uniqueCoinIds = [...new Set(votes.map(v => v.coin_id))];

        // Fetch coin details from CoinGecko (with caching)
        const coinDetailsMap = {};

        try {
            const cacheKey = `coin_details_${uniqueCoinIds.join(',')}`;
            let coinDetails = myCache.get(cacheKey);

            if (!coinDetails) {
                const response = await axios.get('https://api.coingecko.com/api/v3/coins/markets', {
                    params: {
                        vs_currency: 'usd',
                        ids: uniqueCoinIds.join(','),
                        order: 'market_cap_desc',
                        sparkline: false
                    }
                });
                coinDetails = response.data;
                myCache.set(cacheKey, coinDetails);
                apiHitsToday++;
            }

            // Create a map for quick lookup
            coinDetails.forEach(coin => {
                coinDetailsMap[coin.id] = {
                    image: coin.image,
                    currentPrice: coin.current_price,
                    symbol: coin.symbol
                };
            });
        } catch (error) {
            console.error('Error fetching coin details:', error.message);
            // Continue without coin details if API fails
        }

        // Merge vote data with coin details
        const votesWithDetails = votes.map(vote => ({
            coinId: vote.coin_id,
            coinName: vote.coin_name,
            votedAt: vote.created_at,
            coinImage: coinDetailsMap[vote.coin_id]?.image || null,
            currentPrice: coinDetailsMap[vote.coin_id]?.currentPrice || null,
            symbol: coinDetailsMap[vote.coin_id]?.symbol || null
        }));

        res.json({ votes: votesWithDetails });
    } catch (error) {
        console.error('Get voting history error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// --- CoinGecko Proxy Route ---
app.get('/api/coins', async (req, res) => {
    const { vs_currency = 'usd', order = 'market_cap_desc', per_page = 100, page = 1, sparkline = false } = req.query;
    const cacheKey = `coins_${vs_currency}_${order}_${per_page}_${page}_${sparkline}`;

    const cachedData = myCache.get(cacheKey);
    if (cachedData) {
        return res.json(cachedData);
    }

    try {
        apiHitsToday++;
        const response = await axios.get('https://api.coingecko.com/api/v3/coins/markets', {
            params: {
                vs_currency,
                order,
                per_page,
                page,
                sparkline
            }
        });

        myCache.set(cacheKey, response.data);
        res.json(response.data);
    } catch (error) {
        console.error('CoinGecko API error:', error.message);
        res.status(500).json({ error: 'Failed to fetch coin data' });
    }
});

// Search for cryptocurrencies
app.get('/api/coins/search', async (req, res) => {
    const { query } = req.query;

    if (!query) {
        return res.status(400).json({ error: 'Query parameter is required' });
    }

    const cacheKey = `search_${query}`;

    const cachedData = myCache.get(cacheKey);
    if (cachedData) {
        return res.json(cachedData);
    }

    try {
        apiHitsToday++;
        const response = await axios.get('https://api.coingecko.com/api/v3/search', {
            params: { query }
        });

        myCache.set(cacheKey, response.data);
        res.json(response.data);
    } catch (error) {
        console.error('CoinGecko Search API error:', error.message);
        res.status(500).json({ error: 'Failed to search coins' });
    }
});

// Get detailed data for specific coins by IDs
app.get('/api/coins/details', async (req, res) => {
    const { ids, vs_currency = 'usd' } = req.query;

    if (!ids) {
        return res.status(400).json({ error: 'IDs parameter is required' });
    }

    const cacheKey = `details_${ids}_${vs_currency}`;

    const cachedData = myCache.get(cacheKey);
    if (cachedData) {
        return res.json(cachedData);
    }

    try {
        apiHitsToday++;
        const response = await axios.get('https://api.coingecko.com/api/v3/coins/markets', {
            params: {
                vs_currency,
                ids,
                order: 'market_cap_desc',
                sparkline: false
            }
        });

        myCache.set(cacheKey, response.data);
        res.json(response.data);
    } catch (error) {
        console.error('CoinGecko Details API error:', error.message);
        res.status(500).json({ error: 'Failed to fetch coin details' });
    }
});

// --- Articles Routes ---

// GET all active articles (newest first by created_at)
app.get('/api/articles', async (req, res) => {
    try {
        const [rows] = await db.query(
            'SELECT id, title, source, category, description, full_content, created_at, updated_at FROM articles WHERE is_active = 1 ORDER BY created_at DESC'
        );
        const articles = rows.map(row => ({
            ...row,
            fullContent: JSON.parse(row.full_content)
        }));
        res.json(articles);
    } catch (error) {
        console.error('Get articles error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// GET single article by ID
app.get('/api/articles/:id', async (req, res) => {
    try {
        const [rows] = await db.query(
            'SELECT id, title, source, category, description, full_content, created_at, updated_at FROM articles WHERE id = ? AND is_active = 1',
            [req.params.id]
        );
        if (rows.length === 0) return res.status(404).json({ error: 'Article not found' });
        const article = { ...rows[0], fullContent: JSON.parse(rows[0].full_content) };
        res.json(article);
    } catch (error) {
        console.error('Get article error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// POST create new article (super admin only)
app.post('/api/articles', authenticateSuperAdmin, async (req, res) => {
    const { title, source, category, description, fullContent } = req.body;
    if (!title || !source || !category || !description || !fullContent) {
        return res.status(400).json({ error: 'All fields are required: title, source, category, description, fullContent (array)' });
    }
    if (!Array.isArray(fullContent) || fullContent.length === 0) {
        return res.status(400).json({ error: 'fullContent must be a non-empty array of paragraphs' });
    }
    try {
        const [result] = await db.query(
            'INSERT INTO articles (title, source, category, description, full_content) VALUES (?, ?, ?, ?, ?)',
            [title, source, category, description, JSON.stringify(fullContent)]
        );
        res.status(201).json({ message: 'Article created', id: result.insertId });
    } catch (error) {
        console.error('Create article error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// PUT update article (super admin only)
app.put('/api/articles/:id', authenticateSuperAdmin, async (req, res) => {
    const { title, source, category, description, fullContent } = req.body;
    try {
        const updates = {};
        if (title) updates.title = title;
        if (source) updates.source = source;
        if (category) updates.category = category;
        if (description) updates.description = description;
        if (fullContent) updates.full_content = JSON.stringify(fullContent);
        if (Object.keys(updates).length === 0) {
            return res.status(400).json({ error: 'Nothing to update' });
        }
        const fields = Object.keys(updates).map(k => `${k} = ?`).join(', ');
        const values = [...Object.values(updates), req.params.id];
        await db.query(`UPDATE articles SET ${fields} WHERE id = ?`, values);
        res.json({ message: 'Article updated' });
    } catch (error) {
        console.error('Update article error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// DELETE article (soft delete, super admin only)
app.delete('/api/articles/:id', authenticateSuperAdmin, async (req, res) => {
    try {
        await db.query('UPDATE articles SET is_active = 0 WHERE id = ?', [req.params.id]);
        res.json({ message: 'Article deleted' });
    } catch (error) {
        console.error('Delete article error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// --- Trending Topics Routes ---

// GET all active trending topics
app.get('/api/trending-topics', async (req, res) => {
    try {
        const [rows] = await db.query(
            'SELECT id, title, trend FROM trending_topics WHERE is_active = 1 ORDER BY sort_order ASC'
        );
        res.json(rows);
    } catch (error) {
        console.error('Get trending topics error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// POST create trending topic (super admin only)
app.post('/api/trending-topics', authenticateSuperAdmin, async (req, res) => {
    const { title, trend } = req.body;
    if (!title || !trend) {
        return res.status(400).json({ error: 'title and trend are required' });
    }
    try {
        const [result] = await db.query(
            'INSERT INTO trending_topics (title, trend) VALUES (?, ?)',
            [title, trend]
        );
        res.status(201).json({ message: 'Trending topic created', id: result.insertId });
    } catch (error) {
        console.error('Create trending topic error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// PUT update trending topic (super admin only)
app.put('/api/trending-topics/:id', authenticateSuperAdmin, async (req, res) => {
    const { title, trend } = req.body;
    try {
        const updates = {};
        if (title) updates.title = title;
        if (trend) updates.trend = trend;
        if (Object.keys(updates).length === 0) {
            return res.status(400).json({ error: 'Nothing to update' });
        }
        const fields = Object.keys(updates).map(k => `${k} = ?`).join(', ');
        const values = [...Object.values(updates), req.params.id];
        await db.query(`UPDATE trending_topics SET ${fields} WHERE id = ?`, values);
        res.json({ message: 'Trending topic updated' });
    } catch (error) {
        console.error('Update trending topic error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// DELETE trending topic (super admin only)
app.delete('/api/trending-topics/:id', authenticateSuperAdmin, async (req, res) => {
    try {
        await db.query('UPDATE trending_topics SET is_active = 0 WHERE id = ?', [req.params.id]);
        res.json({ message: 'Trending topic deleted' });
    } catch (error) {
        console.error('Delete trending topic error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// --- Admin Stats Route ---
app.get('/api/admin/stats', async (req, res) => {
    try {
        const todayEST = getTodayDateEST();

        // 1. Total Users
        const [userRows] = await db.query('SELECT COUNT(*) as count FROM users');
        const totalUsers = userRows[0].count;

        // 2. Total Votes (all-time)
        const [voteRows] = await db.query('SELECT COUNT(*) as count FROM votes');
        const totalVotes = voteRows[0].count;

        // 3. Top Coin (All Time)
        const [topCoinRows] = await db.query('SELECT coin_name, COUNT(*) as count FROM votes GROUP BY coin_name ORDER BY count DESC LIMIT 1');
        const topCoinAllTime = topCoinRows.length > 0 ? topCoinRows[0] : null;

        // 4. Top Coin (Last 24h)
        const [topCoin24hRows] = await db.query(`
            SELECT coin_name, COUNT(*) as count 
            FROM votes 
            WHERE created_at >= NOW() - INTERVAL 1 DAY 
            GROUP BY coin_name 
            ORDER BY count DESC 
            LIMIT 1
        `);
        const topCoin24h = topCoin24hRows.length > 0 ? topCoin24hRows[0] : null;

        // 5. Votes cast TODAY (EST) — votes + share_logs
        const [votesTodayRows] = await db.query(`
            SELECT COUNT(*) as count
            FROM (
                SELECT id FROM votes WHERE DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?
                UNION ALL
                SELECT id FROM share_logs WHERE DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?
            ) as combined
        `, [todayEST, todayEST]);
        const votesToday = votesTodayRows[0].count;

        // 6. New accounts created TODAY (EST)
        const [newUserRows] = await db.query(
            `SELECT COUNT(*) as count FROM users WHERE DATE(CONVERT_TZ(created_at, '+00:00', '-05:00')) = ?`,
            [todayEST]
        );
        const newUsersToday = newUserRows[0].count;

        // 7. Unique visitors today (in-memory Set)
        const visitorsCount = visitorsToday.size;

        res.json({
            apiHitsToday,
            totalUsers,
            totalVotes,
            topCoinAllTime,
            topCoin24h,
            votesToday,
            newUsersToday,
            visitorsToday: visitorsCount
        });
    } catch (error) {
        console.error('Admin stats error:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Import migration scripts
const createShareLogsTable = require('./migrations/create_share_logs_table');
const ensureSharePointsColumn = require('./ensure_share_points');
const createArticlesAndTrending = require('./migrations/create_articles_and_trending');

// Initialize database and start server
const init = async () => {
    try {
        // Run migrations
        await createShareLogsTable();
        await ensureSharePointsColumn();
        await createArticlesAndTrending();

        app.listen(PORT, () => {
            console.log(`Server running on port ${PORT}`);
        });
    } catch (error) {
        console.error('Failed to initialize server:', error);
        process.exit(1);
    }
};

init();