import * as readline from 'readline';
import * as fs from 'fs';
import * as path from 'path';
import {Server} from "socket.io";
import * as os from 'os';

class CommandManager {
    private commands: Map<string, Function> = new Map();
    private rl: readline.Interface;
    private io: Server|null = null;

    public constructor() {
        this.rl = readline.createInterface({
            input: process.stdin,
            output: process.stdout
        });

        this.loadCommands();
    }

    public async boot(io: Server) {
        this.io = io as Server;
        console.log('[✅] Command manager loaded');
        await this.startPrompt();
    }

    private async startPrompt() {
        this.rl.question('> ', (command: string) => {
            this.processCommand(command);
            this.startPrompt();
        });
    }

    private async processCommand(command: string): Promise<any> {
        const [cmd, ...args] = command.trim().toLowerCase().split(' ');
        if (this.commands.has(cmd)) {
            this.commands.get(cmd)?.(args, this.io as Server);
        } else {
            switch (cmd) {
                case 'exit':
                    console.log('Goodbye!');
                    this.rl.close();
                    process.exit(0);
                    break;
                default:
                    console.log(`Unknown command: ${command}`);
                    break;
            }
        }
    }

    private async loadCommands() {
        const commandsDir = path.resolve(__dirname, 'commands');

        try {
            const files: string[] = await fs.promises.readdir(commandsDir);
            for (const file of files) {
                const ext = path.extname(file);
                const commandName = path.basename(file, ext);
                const commandPath = path.join(commandsDir, file);

                if (os.platform() === 'win32') {
                    const commandPath = path.join(commandsDir, file).replace(/\\/g, '/');
                }

                const module = await import(commandPath);
                this.registerCommand(commandName, module.default);
            }
        } catch (error: any) {
            console.error('[❌] Failed to load command files:', error.message);
        }
    }

    private registerCommand(
        name: string,
        command: (args: string[], io: Server) => void
    ) {
        if (this.commands.has(name)) {
            console.warn(`Command '${name}' is already registered. Overwriting...`);
        }
        this.commands.set(name, command);
        console.log(`Registered command: ${name}`);
    }
}

export default new CommandManager();