require("dotenv").config();
const sqlite3 = require('sqlite3').verbose();
const db = new sqlite3.Database(process.env.DB_PATH || 'database.db');

require('./migrations')(db).then(() => {
    console.log('All migrations completed successfully');
}).catch(err => {
    console.error('Error running migrations:', err);
});

const Discord = require("discord.js");

const fs = require('fs');
const path = require("path");

const client = new Discord.Client({
    intents: [
        Discord.IntentsBitField.Flags.Guilds,
        Discord.IntentsBitField.Flags.GuildModeration,
        Discord.IntentsBitField.Flags.GuildMembers
    ]
})


// Presence Loop
var presenceCounter = 0;
var presenceInterval = 60; // Default to 60 seconds, can be adjusted in presence.json
const presenceLoop = () => {
    console.log("Doing presence update...");
    try {
        const presenceConfig = JSON.parse(fs.readFileSync('presence.json', 'utf8'));
        if (!presenceConfig.presenceList || !Array.isArray(presenceConfig.presenceList) || presenceConfig.presenceList.length === 0) {
            console.warn('Presence list is empty or not defined in presence.json');
            return;
        }
        if (!presenceConfig.presenceList[presenceCounter]) {
            presenceCounter = 0; // Reset counter if out of bounds
        }
        presenceInterval = presenceConfig.interval || 60; // Use interval from config or default to 60 seconds
        console.log(`Setting presence to: ${presenceConfig.presenceList[presenceCounter]}; Counter: ${presenceCounter}; Waiting ${presenceInterval} seconds for next update...`);
        client.user.setPresence({
            activities: [
                {
                    name: presenceConfig.presenceList[presenceCounter],
                    type: Discord.ActivityType.Custom
                }
            ]
        });

        if (presenceConfig.random) {
            console.log("Random presence enabled, selecting a random presence for next update.");
            presenceCounter = Math.floor(Math.random() * presenceConfig.presenceList.length);
        } else {
            presenceCounter++;
        }
    } catch (err) {
        console.error('Failed to load presence config:', err);
    }
    setTimeout(presenceLoop, presenceInterval * 1000); // Wait for the specified interval before next update
}

client.once("ready", async () => {
    console.log(`Logged in as ${client.user.username} (${client.user.id})`);

    // Register commands
    const commands = require("./commands.js")
    await (async () => {
        const rest = new Discord.REST({ version: '10' }).setToken(client.token);
        try {
            //Global
            console.log(`Registering global commands`);
            await rest.put(Discord.Routes.applicationCommands(client.user.id), { body: commands.globalCommands })
            console.log(`Registered global commands successfully`);
        } catch (error) {
            console.error(error);
        }

        if (process.env.REFRESH_ADMIN_GUILD_COMMANDS === 'true') {
            // Unregister guild commands from all guilds
            try {
                console.log(`Unregistering guild commands from all guilds`);
                const guilds = await client.guilds.fetch();
                console.log(`Found ${guilds.size} guilds to unregister commands from`);
                if (guilds.size === 0) {
                    console.log(`No guilds found, skipping unregistration`);
                    return;
                }
                for (const guild of guilds.values()) {
                    await rest.put(Discord.Routes.applicationGuildCommands(client.user.id, guild.id), { body: [] });
                }
                console.log(`Unregistered guild commands from all guilds successfully`);
            } catch (error) {
                console.error(error);
            }

            try {
                //Guild
                console.log(`Registering guild commands for admin guild`);
                await rest.put(Discord.Routes.applicationGuildCommands(client.user.id, process.env.ADMIN_GUILD), { body: commands.adminGuildCommands })
                console.log(`Registered guild commands for admin guild successfully`);
            } catch (error) {
                console.error(error);
            }
        }
    })();

    presenceLoop();
});

client.on("error", (error) => {
    console.error("An error occurred:", error);
});

client.on("interactionCreate", async (interaction) => {
    switch (interaction.type) {
        case Discord.InteractionType.ApplicationCommand:
            const command = require(`./interactions/commands/${interaction.commandName}.js`);
            if (command) {
                try {
                    await command.execute(interaction, db, client);
                } catch (error) {
                    console.error(`Error executing command ${interaction.commandName}:`, error);
                    await interaction.reply({ content: 'There was an error while executing this command!', ephemeral: true });
                }
            } else {
                console.warn(`Command ${interaction.commandName} not found.`);
                await interaction.reply({ content: 'This command does not exist.', ephemeral: true });
            }
            break;
        case Discord.InteractionType.ModalSubmit:
            const modal = require(`./interactions/modals/${interaction.customId}.js`)(interaction, db, client);
            if (modal) {
                try {
                    await modal.execute();
                } catch (error) {
                    console.error(`Error executing modal ${interaction.customId}:`, error);
                    await interaction.reply({ content: 'There was an error while processing this modal!', ephemeral: true });
                }
            } else {
                console.warn(`Modal ${interaction.customId} not found.`);
                await interaction.reply({ content: 'This modal does not exist.', ephemeral: true });
            }
            break;
        default:
            console.warn(`Unhandled interaction type: ${interaction.type}`);
            await interaction.reply({ content: 'This interaction type is not supported.', ephemeral: true });
            break;
    }
});

client.on("guildMemberAdd", async (member) => {
    require("./eventHandlers/guildMemberAdd.js")(member, db, client);
});

client.login(process.env.TOKEN).then(() => {
    console.log("Bot is online!");
}).catch(err => {
    console.error("Failed to log in:", err);
});