import express from 'express';
import { createServer } from 'http';
import { Server } from 'socket.io';
import cors from 'cors';
import bcrypt from 'bcrypt';
import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';
import { dirname } from 'path';

// Get __dirname equivalent in ES modules
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

const app = express();
const server = createServer(app);
const io = new Server(server, {
    cors: {
        origin: "*",
        methods: ["GET", "POST"]
    }
});

// Middleware
app.use(cors());
app.use(express.json());
app.use(express.static('public'));

// Configuration
const CONFIG = {
    passwords: {
        addPoints: 'add123',
        admin: 'admin456'
    },
    timers: {
        solo: 15 * 60, // 15 minutes in seconds
        together: 60 * 60, // 1 hour in seconds
        finishUp: 2 * 60 // 2 minutes in seconds
    },
    port: 80
};

// Data file path
const DATA_FILE = path.join(__dirname, 'data', 'gameState.json');

// Initial state structure
const initialState = {
    soloPoints: [],
    togetherPoints: [],
    customPoints: [],
    activeTimers: {},
    pausedTimers: {},
    activityLog: [],
    togetherUsedToday: 0,
    lastResetDate: new Date().toDateString(),
    lastWeeklyReset: '',
    connectedClients: 0
};

// Load or create game state
let gameState = loadGameState();

// Load game state from file
function loadGameState() {
    try {
        if (fs.existsSync(DATA_FILE)) {
            const data = fs.readFileSync(DATA_FILE, 'utf8');
            const savedState = JSON.parse(data);
            // Convert timer maps back from objects
            savedState.activeTimers = savedState.activeTimers || {};
            savedState.pausedTimers = savedState.pausedTimers || {};
            return { ...initialState, ...savedState };
        }
    } catch (error) {
        console.error('Error loading game state:', error);
    }

    // Initialize with default points
    const state = { ...initialState };
    state.soloPoints = Array(5).fill(null).map((_, i) => ({
        id: `solo_${i}`,
        type: 'solo',
        status: 'available',
        duration: CONFIG.timers.solo,
        label: '15m'
    }));

    state.togetherPoints = Array(4).fill(null).map((_, i) => ({
        id: `together_${i}`,
        type: 'together',
        status: 'available',
        duration: CONFIG.timers.together,
        label: '1h'
    }));

    return state;
}

// Save game state to file
function saveGameState() {
    try {
        const dir = path.dirname(DATA_FILE);
        if (!fs.existsSync(dir)) {
            fs.mkdirSync(dir, { recursive: true });
        }
        fs.writeFileSync(DATA_FILE, JSON.stringify(gameState, null, 2));
    } catch (error) {
        console.error('Error saving game state:', error);
    }
}

// Check and reset daily limit
function checkDayReset() {
    const today = new Date().toDateString();
    if (gameState.lastResetDate !== today) {
        gameState.togetherUsedToday = 0;
        gameState.lastResetDate = today;
        saveGameState();
        return true;
    }
    return false;
}

// Add log entry
function addLogEntry(message) {
    const entry = {
        timestamp: new Date().toISOString(),
        message: message
    };

    gameState.activityLog.unshift(entry);

    // Keep only last 5 entries
    if (gameState.activityLog.length > 5) {
        gameState.activityLog = gameState.activityLog.slice(0, 5);
    }

    saveGameState();
}

// Find point by ID
function findPoint(pointId) {
    return [...gameState.soloPoints, ...gameState.togetherPoints, ...gameState.customPoints]
        .find(p => p.id === pointId);
}

// Timer management
const timerIntervals = new Map();

function startTimer(pointId, duration, type = 'normal') {
    const startTime = Date.now();
    const timer = {
        startTime,
        duration: duration * 1000,
        remainingTime: duration * 1000,
        type,
        pointId
    };

    gameState.activeTimers[pointId] = timer;

    // Set up interval to check timer
    const interval = setInterval(() => {
        const elapsed = Date.now() - startTime;
        const remaining = timer.duration - elapsed;

        if (remaining <= 0) {
            clearInterval(interval);
            timerIntervals.delete(pointId);
            handleTimerComplete(pointId);
        } else {
            // Emit timer update
            io.emit('timerUpdate', {
                pointId,
                remainingSeconds: Math.floor(remaining / 1000),
                type: timer.type
            });
        }
    }, 1000);

    timerIntervals.set(pointId, interval);
    saveGameState();
}

function handleTimerComplete(pointId) {
    const timer = gameState.activeTimers[pointId];
    if (!timer) return;

    delete gameState.activeTimers[pointId];

    // Handle different completion types
    if (timer.type === 'finishUp') {
        const point = findPoint(pointId);
        if (point) {
            point.status = 'used';
            addLogEntry(`${point.customName || point.type} point finish-up time completed`);
            io.emit('timerComplete', { pointId, type: 'finishUp' });
            io.emit('stateUpdate', gameState);
        }
    } else if (timer.type === 'episode' || timer.type === 'movie') {
        // Remove temporary point
        gameState.customPoints = gameState.customPoints.filter(p => p.id !== pointId);
        addLogEntry(`${timer.type} completed`);
        io.emit('timerComplete', { pointId, type: timer.type });
        io.emit('stateUpdate', gameState);
    } else {
        // Regular timer - offer finish-up
        io.emit('timerComplete', { pointId, type: 'normal', offerFinishUp: true });
    }

    saveGameState();
}

// Socket.IO connection handling
io.on('connection', (socket) => {
    console.log('Client connected:', socket.id);
    gameState.connectedClients++;

    // Check day reset on new connection
    if (checkDayReset()) {
        io.emit('stateUpdate', gameState);
    }

    // Send initial state
    socket.emit('initialState', gameState);

    // Handle disconnection
    socket.on('disconnect', () => {
        console.log('Client disconnected:', socket.id);
        gameState.connectedClients--;
    });

    // Use point
    socket.on('usePoint', (data) => {
        const { pointId } = data;
        const point = findPoint(pointId);

        if (!point || point.status !== 'available') {
            socket.emit('error', { message: 'Point not available' });
            return;
        }

        // Check solo limitation
        if (point.type === 'solo' || point.customType === 'solo') {
            const activeSolo = [...gameState.soloPoints, ...gameState.customPoints]
                .find(p => (p.type === 'solo' || p.customType === 'solo') &&
                    (p.status === 'active' || p.status === 'paused'));

            if (activeSolo) {
                socket.emit('error', { message: 'Only one solo point at a time' });
                return;
            }
        }

        // Check together daily limit
        if (point.type === 'together' || point.customType === 'together') {
            if (gameState.togetherUsedToday >= 1) {
                socket.emit('error', { message: 'Daily together limit reached' });
                return;
            }
            gameState.togetherUsedToday++;
        }

        point.status = 'active';
        startTimer(pointId, point.duration || CONFIG.timers[point.type]);
        addLogEntry(`Started ${point.customName || point.type} point (${point.label})`);
        io.emit('stateUpdate', gameState);
    });

    // Pause timer
    socket.on('pauseTimer', (data) => {
        const { pointId } = data;
        const point = findPoint(pointId);
        const timer = gameState.activeTimers[pointId];

        if (!point || !timer) return;

        // Clear interval
        const interval = timerIntervals.get(pointId);
        if (interval) {
            clearInterval(interval);
            timerIntervals.delete(pointId);
        }

        point.status = 'paused';
        const elapsed = Date.now() - timer.startTime;
        timer.remainingTime = Math.max(0, timer.duration - elapsed);

        gameState.pausedTimers[pointId] = timer;
        delete gameState.activeTimers[pointId];

        addLogEntry(`Paused ${point.customName || point.type} point`);
        io.emit('stateUpdate', gameState);
    });

    // Resume timer
    socket.on('resumeTimer', (data) => {
        const { pointId } = data;
        const point = findPoint(pointId);
        const timer = gameState.pausedTimers[pointId];

        if (!point || !timer) return;

        point.status = 'active';
        delete gameState.pausedTimers[pointId];

        // Restart with remaining time
        startTimer(pointId, timer.remainingTime / 1000, timer.type);
        addLogEntry(`Resumed ${point.customName || point.type} point`);
        io.emit('stateUpdate', gameState);
    });

    // Admin authentication
    socket.on('adminAuth', (data) => {
        const { password } = data;
        if (password === CONFIG.passwords.admin) {
            socket.emit('adminAuthSuccess');
            addLogEntry('Admin mode activated');
        } else {
            socket.emit('adminAuthFailed');
        }
    });

    // Add points with password
    socket.on('addPoints', (data) => {
        const { password, type, count } = data;

        if (password !== CONFIG.passwords.addPoints) {
            socket.emit('error', { message: 'Incorrect password' });
            return;
        }

        for (let i = 0; i < count; i++) {
            const newPoint = {
                id: `${type}_${Date.now()}_${i}`,
                type,
                status: 'available',
                duration: CONFIG.timers[type],
                label: type === 'solo' ? '15m' : '1h'
            };

            if (type === 'solo') {
                gameState.soloPoints.push(newPoint);
            } else {
                gameState.togetherPoints.push(newPoint);
            }
        }

        addLogEntry(`Added ${count} ${type} point(s)`);
        io.emit('stateUpdate', gameState);
    });

    // Quick add (admin only)
    socket.on('quickAddPoint', (data) => {
        const { type } = data;
        const newPoint = {
            id: `${type}_${Date.now()}`,
            type,
            status: 'available',
            duration: CONFIG.timers[type],
            label: type === 'solo' ? '15m' : '1h'
        };

        if (type === 'solo') {
            gameState.soloPoints.push(newPoint);
        } else {
            gameState.togetherPoints.push(newPoint);
        }

        addLogEntry(`Admin added 1 ${type} point`);
        io.emit('stateUpdate', gameState);
    });

    // Remove point
    socket.on('removePoint', (data) => {
        const { pointId } = data;
        const point = findPoint(pointId);

        if (!point) {
            socket.emit('error', { message: 'Point not found' });
            return;
        }

        // Handle episode/movie removal
        const timer = gameState.activeTimers[pointId] || gameState.pausedTimers[pointId];
        if (timer && (timer.type === 'episode' || timer.type === 'movie')) {
            // Restore consumed solo points
            if (timer.pointIds) {
                timer.pointIds.forEach(soloId => {
                    const soloPoint = gameState.soloPoints.find(p => p.id === soloId);
                    if (soloPoint) soloPoint.status = 'available';
                });
            }

            // Clean up timers
            const interval = timerIntervals.get(pointId);
            if (interval) {
                clearInterval(interval);
                timerIntervals.delete(pointId);
            }

            delete gameState.activeTimers[pointId];
            delete gameState.pausedTimers[pointId];
            gameState.customPoints = gameState.customPoints.filter(p => p.id !== pointId);

            addLogEntry(`Admin removed ${timer.type} (restored solo points)`);
        } else {
            // Regular point removal
            if (point.type === 'solo') {
                gameState.soloPoints = gameState.soloPoints.filter(p => p.id !== pointId);
            } else if (point.type === 'together') {
                gameState.togetherPoints = gameState.togetherPoints.filter(p => p.id !== pointId);
            } else {
                gameState.customPoints = gameState.customPoints.filter(p => p.id !== pointId);
            }

            // Clean up any timers
            const interval = timerIntervals.get(pointId);
            if (interval) {
                clearInterval(interval);
                timerIntervals.delete(pointId);
            }

            delete gameState.activeTimers[pointId];
            delete gameState.pausedTimers[pointId];

            addLogEntry(`Admin removed ${point.customName || point.type} point`);
        }

        io.emit('stateUpdate', gameState);
    });

    // Expire timer
    socket.on('expireTimer', (data) => {
        const { pointId } = data;
        const timer = gameState.activeTimers[pointId] || gameState.pausedTimers[pointId];

        if (!timer) return;

        // Clear existing interval
        const interval = timerIntervals.get(pointId);
        if (interval) {
            clearInterval(interval);
            timerIntervals.delete(pointId);
        }

        // Set to expire in 1 second
        timer.startTime = Date.now() - timer.duration + 1000;
        timer.remainingTime = 1000;
        gameState.activeTimers[pointId] = timer;
        delete gameState.pausedTimers[pointId];

        const point = findPoint(pointId);
        if (point) point.status = 'active';

        // Restart timer with 1 second
        startTimer(pointId, 1, timer.type);

        addLogEntry(`Admin expired ${timer.type || 'timer'}`);
        io.emit('stateUpdate', gameState);
    });

    // Reset all points
    socket.on('resetAllPoints', () => {
        // Clear all intervals
        timerIntervals.forEach((interval) => clearInterval(interval));
        timerIntervals.clear();

        // Reset to initial state with 5 solo and 4 together points
        gameState.soloPoints = Array(5).fill(null).map((_, i) => ({
            id: `solo_${Date.now()}_${i}`,
            type: 'solo',
            status: 'available',
            duration: CONFIG.timers.solo,
            label: '15m'
        }));

        gameState.togetherPoints = Array(4).fill(null).map((_, i) => ({
            id: `together_${Date.now()}_${i}`,
            type: 'together',
            status: 'available',
            duration: CONFIG.timers.together,
            label: '1h'
        }));

        // Clear custom points
        gameState.customPoints = [];

        gameState.activeTimers = {};
        gameState.pausedTimers = {};

        addLogEntry('All points reset by admin');
        io.emit('stateUpdate', gameState);
    });

    // Reset daily limit
    socket.on('resetDailyLimit', () => {
        gameState.togetherUsedToday = 0;
        gameState.lastResetDate = new Date().toDateString();

        addLogEntry('Daily together point limit reset by admin');
        io.emit('stateUpdate', gameState);
    });

    // Clear log
    socket.on('clearLog', () => {
        gameState.activityLog = [];
        addLogEntry('Activity log cleared by admin');
        io.emit('stateUpdate', gameState);
    });

    // Create custom timer
    socket.on('createCustomTimer', (data) => {
        const { name, hours, minutes, pointType } = data;

        const duration = (hours * 3600) + (minutes * 60);
        const label = hours > 0 ? `${hours}h${minutes > 0 ? minutes : ''}` : `${minutes}m`;

        const customPoint = {
            id: `custom_${Date.now()}`,
            type: pointType === 'custom' ? 'solo' : pointType,
            customType: pointType,
            customName: name,
            status: 'available',
            duration: duration,
            label: label
        };

        gameState.customPoints.push(customPoint);
        addLogEntry(`Admin created custom timer: ${name} (${label})`);
        io.emit('stateUpdate', gameState);
    });

    // Episode/Movie selection
    socket.on('confirmSelection', (data) => {
        const { selectedPoints, type } = data;

        // Mark selected points as used immediately
        selectedPoints.forEach(pointId => {
            const point = gameState.soloPoints.find(p => p.id === pointId);
            if (point) point.status = 'used';
        });

        const pointCount = selectedPoints.length;
        const durationText = type === 'episode' ? '30 minutes' : '2 hours';
        addLogEntry(`Used ${pointCount} solo points for ${type} (${durationText})`);

        io.emit('stateUpdate', gameState);
    });

    // Handle finish-up response
    socket.on('finishUpResponse', (data) => {
        const { pointId, accepted } = data;
        const point = findPoint(pointId);

        if (!point) return;

        if (accepted) {
            point.status = 'active';
            startTimer(pointId, CONFIG.timers.finishUp, 'finishUp');
            addLogEntry(`${point.customName || point.type} point completed - using 2min finish-up time`);
        } else {
            point.status = 'used';
            addLogEntry(`${point.customName || point.type} point completed`);
        }

        io.emit('stateUpdate', gameState);
    });
});

// REST API endpoints
app.get('/api/state', (req, res) => {
    res.json(gameState);
});

app.get('/api/config', (req, res) => {
    res.json({
        timers: CONFIG.timers,
        port: CONFIG.port
    });
});

// Scheduled tasks
function scheduleResets() {
    // Check every minute for reset times
    setInterval(() => {
        const now = new Date();
        const hours = now.getHours();
        const minutes = now.getMinutes();
        const day = now.getDay(); // 0 = Sunday, 1 = Monday, etc.

        // Daily reset at 00:01
        if (hours === 0 && minutes === 1) {
            // Reset daily limit
            const today = new Date().toDateString();
            if (gameState.lastResetDate !== today) {
                gameState.togetherUsedToday = 0;
                gameState.lastResetDate = today;
                addLogEntry('Daily together limit reset automatically');
                io.emit('stateUpdate', gameState);
                saveGameState();
            }
        }

        // Weekly reset on Monday at 00:01
        if (day === 1 && hours === 0 && minutes === 1) {
            // Check if we haven't already reset this week
            const lastWeeklyReset = gameState.lastWeeklyReset || '';
            const thisWeek = `${now.getFullYear()}-W${getWeekNumber(now)}`;

            if (lastWeeklyReset !== thisWeek) {
                // Reset to 5 solo and 4 together
                gameState.soloPoints = Array(5).fill(null).map((_, i) => ({
                    id: `solo_${Date.now()}_${i}`,
                    type: 'solo',
                    status: 'available',
                    duration: CONFIG.timers.solo,
                    label: '15m'
                }));

                gameState.togetherPoints = Array(4).fill(null).map((_, i) => ({
                    id: `together_${Date.now()}_${i}`,
                    type: 'together',
                    status: 'available',
                    duration: CONFIG.timers.together,
                    label: '1h'
                }));

                // Clear custom points and timers
                gameState.customPoints = [];
                gameState.activeTimers = {};
                gameState.pausedTimers = {};
                gameState.lastWeeklyReset = thisWeek;

                // Clear all timer intervals
                timerIntervals.forEach((interval) => clearInterval(interval));
                timerIntervals.clear();

                addLogEntry('Weekly points reset automatically (Monday 00:01)');
                io.emit('stateUpdate', gameState);
                saveGameState();
            }
        }
    }, 60000); // Check every minute
}

// Helper function to get week number
function getWeekNumber(date) {
    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
    const dayNum = d.getUTCDay() || 7;
    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
    return Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
}

// Start server
server.listen(CONFIG.port, () => {
    console.log(`Point Tracker Server running on port ${CONFIG.port}`);
    console.log(`WebSocket server ready for connections`);

    // Check day reset on startup
    checkDayReset();

    // Start scheduled resets
    scheduleResets();

    // Restore any active timers
    Object.entries(gameState.activeTimers).forEach(([pointId, timer]) => {
        const elapsed = Date.now() - timer.startTime;
        const remaining = timer.duration - elapsed;

        if (remaining > 0) {
            // Resume timer
            const point = findPoint(pointId);
            if (point) {
                startTimer(pointId, remaining / 1000, timer.type);
                console.log(`Restored active timer for ${pointId}`);
            }
        } else {
            // Timer expired while server was down
            handleTimerComplete(pointId);
        }
    });
});

// Graceful shutdown
process.on('SIGTERM', () => {
    console.log('SIGTERM received, shutting down gracefully');

    // Clear all timer intervals
    timerIntervals.forEach((interval) => clearInterval(interval));

    // Save final state
    saveGameState();

    server.close(() => {
        console.log('Server closed');
        process.exit(0);
    });
});

export { app, server };