"use strict";
/**
 * Test Server for AI Interactive Fiction
 * Simplified version that sends test paragraphs instead of using LLM
 */
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.io = exports.server = exports.app = void 0;
const path_1 = __importDefault(require("path"));
const express_1 = __importDefault(require("express"));
const http_1 = __importDefault(require("http"));
const socket_io_1 = require("socket.io");
const dotenv = __importStar(require("dotenv"));
const fs_1 = require("fs");
const turn_result_1 = require("./interfaces/turn-result");
// Load environment variables
dotenv.config();
// Create Express application
const app = (0, express_1.default)();
exports.app = app;
const server = http_1.default.createServer(app);
exports.server = server;
const io = new socket_io_1.Server(server);
exports.io = io;
// Get port from environment variables or use default
const DEFAULT_PORT = 3001;
const PORT = process.env.PORT ? parseInt(process.env.PORT) : DEFAULT_PORT;
const PORT_RANGE = 300; // Try enough ports to skip OS-excluded ranges.
// Serve static files from the public directory. Keep browser modules uncached
// during local development so fixes are visible without a hard cache clear.
app.use(express_1.default.static(path_1.default.join(__dirname, '../public'), {
    etag: false,
    lastModified: false,
    setHeaders: (res) => {
        res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate');
        res.setHeader('Pragma', 'no-cache');
        res.setHeader('Expires', '0');
    }
}));
// Test paragraphs to send to the client
const TEST_PARAGRAPHS = [
    "You stand at the entrance of a mysterious cave. The air is cool and damp, carrying the scent of earth and ancient stone. Shadows dance on the walls as your torch flickers in the gentle breeze.",
    "As you venture deeper, the passage narrows. Stalactites hang from the ceiling like stone daggers, their surfaces glistening with moisture. The sound of dripping water echoes through the silence.",
    "Suddenly, the passage opens into a vast chamber. Crystal formations catch the light of your torch, sending rainbow reflections across the walls. In the center of the room stands an ancient stone pedestal, its surface carved with symbols from a forgotten language."
];
// Handle socket connections
io.on('connection', (socket) => {
    console.log(`New client connected: ${socket.id}`);
    let currentParagraphIndex = 0;
    let gameRunning = false;
    let nextTurnId = 1;
    const saveGames = new Set();
    const startDemoGame = () => {
        gameRunning = true;
        nextTurnId = 1;
        currentParagraphIndex = 0;
        socket.emit('narrativeResponse', {
            turnId: nextTurnId++,
            paragraphs: [
                ...(0, turn_result_1.textToParagraphs)("#chapter[Interactive Fiction Test]\n\nWelcome to the Interactive Fiction Test. This is a simplified version that sends predefined paragraphs instead of using an LLM."),
                ...(0, turn_result_1.textToParagraphs)(TEST_PARAGRAPHS[0]),
            ],
            choices: [],
            inputMode: 'text',
            gameState: {
                currentRoomId: 'test-room',
            },
        });
    };
    const normalizeSaveSlot = (slot) => {
        const value = Number(slot);
        return Number.isInteger(value) && value > 0 ? value : 1;
    };
    socket.on('gameApi', (request, respond) => {
        try {
            const method = String(request?.method || '');
            const args = Array.isArray(request?.args) ? request.args : [];
            let response;
            switch (method) {
                case 'newGame':
                case 'newGame()':
                    startDemoGame();
                    response = { success: true, result: true, running: true, canLoad: saveGames.size > 0 };
                    break;
                case 'loadGame':
                case 'loadGame()': {
                    const slot = normalizeSaveSlot(args[0]);
                    if (!saveGames.has(slot)) {
                        response = { success: false, error: 'missing_save', result: false };
                        break;
                    }
                    startDemoGame();
                    socket.emit('gameLoaded', { slot });
                    response = { success: true, result: true, running: true, slot };
                    break;
                }
                case 'saveGame':
                case 'saveGame()': {
                    if (!gameRunning) {
                        response = { success: false, error: 'game_not_running', result: false };
                        break;
                    }
                    const slot = normalizeSaveSlot(args[0]);
                    saveGames.add(slot);
                    socket.emit('gameSaved', { slot });
                    response = { success: true, result: true, slot };
                    break;
                }
                case 'hasSaveGame':
                case 'hasSaveGame()': {
                    const slot = normalizeSaveSlot(args[0]);
                    response = { success: true, result: saveGames.has(slot), slot };
                    break;
                }
                case 'getSaveGames':
                case 'getSaveGames()':
                    response = { success: true, result: Array.from(saveGames).sort((a, b) => a - b) };
                    break;
                case 'isGameRunning':
                case 'isGameRunning()':
                    response = { success: true, result: gameRunning };
                    break;
                default:
                    response = { success: false, error: `unknown_method:${method}` };
            }
            if (typeof respond === 'function')
                respond(response);
        }
        catch (error) {
            if (typeof respond === 'function') {
                respond({ success: false, error: error instanceof Error ? error.message : String(error) });
            }
        }
    });
    // Process player command
    socket.on('playerCommand', async (data) => {
        try {
            console.log(`Received command: ${data.command}`);
            // Send narrative response to client
            socket.emit('narrativeResponse', {
                turnId: nextTurnId++,
                paragraphs: (0, turn_result_1.textToParagraphs)(String(data.command || '')),
                choices: [],
                inputMode: 'text',
                gameState: {
                    currentRoomId: "test-room"
                },
                suggestions: ["look around", "examine pedestal", "touch crystals"]
            });
        }
        catch (error) {
            console.error('Error processing command:', error);
            socket.emit('error', { message: 'Failed to process command. Please try again.' });
        }
    });
    // Handle disconnection
    socket.on('disconnect', () => {
        console.log(`Client disconnected: ${socket.id}`);
    });
});
// Ensure required asset folders exist
function ensureDirectories() {
    const dirs = [
        path_1.default.join(__dirname, '../public'),
        path_1.default.join(__dirname, '../public/js'),
        path_1.default.join(__dirname, '../public/css'),
        path_1.default.join(__dirname, '../public/images'),
        path_1.default.join(__dirname, '../public/music'),
        path_1.default.join(__dirname, '../public/sounds'),
        path_1.default.join(__dirname, '../public/fonts')
    ];
    for (const dir of dirs) {
        if (!(0, fs_1.existsSync)(dir)) {
            (0, fs_1.mkdirSync)(dir, { recursive: true });
        }
    }
}
// Copy kokoro-js library from node_modules if not already present
function ensureKokoroJs() {
    const source = path_1.default.join(__dirname, '../node_modules/kokoro-js/dist/index.js');
    const destination = path_1.default.join(__dirname, '../public/js/kokoro-js.js');
    if ((0, fs_1.existsSync)(source) && !(0, fs_1.existsSync)(destination)) {
        (0, fs_1.copyFileSync)(source, destination);
        console.log(`Copied kokoro-js from ${source} to ${destination}`);
    }
}
// Start the server with port fallback
async function startServer(initialPort, range) {
    let currentPort = initialPort;
    const maxPort = initialPort + range;
    // Try ports in the specified range
    while (currentPort < maxPort) {
        try {
            // Ensure directories exist
            ensureDirectories();
            // Ensure kokoro-js is copied
            try {
                ensureKokoroJs();
            }
            catch (error) {
                console.error('Error copying kokoro-js:', error);
            }
            // Try to start the server on the current port
            await new Promise((resolve, reject) => {
                server.removeAllListeners('error');
                server.removeAllListeners('listening');
                server.once('listening', () => {
                    console.log(`AI Interactive Fiction TEST SERVER running on http://localhost:${currentPort}`);
                    console.log('This server is sending predefined test paragraphs instead of using an LLM');
                    resolve();
                });
                server.once('error', (error) => {
                    // If port is in use, try next port
                    if (error.code === 'EADDRINUSE' || error.code === 'EACCES') {
                        console.log(`Port ${currentPort} is unavailable (${error.code}), trying next port...`);
                        server.close();
                        currentPort++;
                        reject();
                    }
                    else {
                        // For other errors, log and reject
                        console.error('Server error:', error);
                        reject(error);
                    }
                });
                server.listen(currentPort);
            });
            // If we reach here, server started successfully
            return;
        }
        catch (error) {
            // If we reach the max port and still fail, throw an error
            if (currentPort >= maxPort - 1) {
                throw new Error(`Failed to start server on ports ${initialPort} to ${maxPort - 1}`);
            }
            // Otherwise try the next port
        }
    }
}
// Start the server when this module is run directly
if (require.main === module) {
    startServer(PORT, PORT_RANGE).catch(error => {
        console.error('Failed to start server:', error);
        process.exit(1);
    });
}
//# sourceMappingURL=test-server.js.map