import 'dotenv/config';
import { Client, GatewayIntentBits } from 'discord.js';
import fs from 'fs';

const PATH = './data/league.json';

function load() {
  return JSON.parse(fs.readFileSync(PATH, 'utf8'));
}

function save(data) {
  fs.writeFileSync(PATH, JSON.stringify(data, null, 2));
}

const client = new Client({
  intents: [GatewayIntentBits.Guilds]
});

client.once('ready', () => {
  console.log(`Logged in as ${client.user.tag}`);
});

client.on('interactionCreate', async interaction => {
  if (!interaction.isChatInputCommand()) return;

  const league = load();

  try {
    switch (interaction.commandName) {

      case 'season-create': {
        const name = interaction.options.getString('name');
        const id = `S${Date.now()}`;

        league.seasons.push({
          id,
          name,
          active: false,
          startDate: new Date().toISOString(),
          endDate: null
        });

        save(league);
        return interaction.reply(`Season **${name}** created with ID \`${id}\``);
      }

      case 'season-set-active': {
        const seasonId = interaction.options.getString('season');

        league.seasons.forEach(s => s.active = s.id === seasonId);

        save(league);
        return interaction.reply(`Season \`${seasonId}\` is now active`);
      }

      case 'team-create': {
        const name = interaction.options.getString('name');
        const seasonId = interaction.options.getString('season');

        const season = league.seasons.find(s => s.id === seasonId);
        if (!season) return interaction.reply({ content: 'Season not found', ephemeral: true });

        const id = `T${Date.now()}`;

        league.teams.push({
          id,
          name,
          seasonId,
          roster: []
        });

        save(league);
        return interaction.reply(`Team **${name}** created with ID \`${id}\``);
      }

      case 'team-roster': {
        const teamId = interaction.options.getString('team');
        const team = league.teams.find(t => t.id === teamId);

        if (!team) return interaction.reply({ content: 'Team not found', ephemeral: true });

        const players = team.roster
          .map(pid => league.players.find(p => p.id === pid))
          .filter(Boolean);

        const list = players.length
          ? players.map(p => `• ${p.name} (${p.position}) [${p.id}]`).join('\n')
          : 'No players yet';

        return interaction.reply(`Roster for **${team.name}**:\n${list}`);
      }

      case 'player-register': {
        const name = interaction.options.getString('name');
        const position = interaction.options.getString('position');
        const user = interaction.options.getUser('user');

        const id = `P${Date.now()}`;

        league.players.push({
          id,
          discordId: user.id,
          name,
          position,
          teamId: null,
          status: 'free'
        });

        save(league);
        return interaction.reply(`Player **${name}** registered with ID \`${id}\``);
      }

      case 'transfer': {
        const playerId = interaction.options.getString('player');
        const toTeamId = interaction.options.getString('to_team');

        const player = league.players.find(p => p.id === playerId);
        const toTeam = league.teams.find(t => t.id === toTeamId);

        if (!player || !toTeam)
          return interaction.reply({ content: 'Player or team not found', ephemeral: true });

        if (player.teamId) {
          const oldTeam = league.teams.find(t => t.id === player.teamId);
          if (oldTeam) oldTeam.roster = oldTeam.roster.filter(id => id !== player.id);
        }

        toTeam.roster.push(player.id);
        player.teamId = toTeam.id;
        player.status = 'contracted';

        save(league);
        return interaction.reply(`Player **${player.name}** transferred to **${toTeam.name}**`);
      }

      case 'loan': {
        const playerId = interaction.options.getString('player');
        const toTeamId = interaction.options.getString('to_team');
        const weeks = interaction.options.getInteger('weeks');

        const player = league.players.find(p => p.id === playerId);
        const toTeam = league.teams.find(t => t.id === toTeamId);

        if (!player || !toTeam)
          return interaction.reply({ content: 'Player or team not found', ephemeral: true });

        toTeam.roster.push(player.id);
        player.status = `loaned (${weeks} weeks)`;

        save(league);
        return interaction.reply(
          `Player **${player.name}** loaned to **${toTeam.name}** for ${weeks} weeks`
        );
      }

      case 'trade': {
        const teamAId = interaction.options.getString('team_a');
        const teamBId = interaction.options.getString('team_b');
        const playersA = interaction.options.getString('players_a').split(',').map(s => s.trim());
        const playersB = interaction.options.getString('players_b').split(',').map(s => s.trim());

        const teamA = league.teams.find(t => t.id === teamAId);
        const teamB = league.teams.find(t => t.id === teamBId);

        if (!teamA || !teamB)
          return interaction.reply({ content: 'Teams not found', ephemeral: true });

        for (const pid of playersA) {
          const p = league.players.find(pl => pl.id === pid);
          if (!p) continue;
          teamA.roster = teamA.roster.filter(id => id !== pid);
          teamB.roster.push(pid);
          p.teamId = teamB.id;
        }

        for (const pid of playersB) {
          const p = league.players.find(pl => pl.id === pid);
          if (!p) continue;
          teamB.roster = teamB.roster.filter(id => id !== pid);
          teamA.roster.push(pid);
          p.teamId = teamA.id;
        }

        save(league);
        return interaction.reply(`Trade completed between **${teamA.name}** and **${teamB.name}**`);
      }
    }
  } catch (err) {
    console.error(err);
    return interaction.reply({ content: 'Error occurred', ephemeral: true });
  }
});

client.login(process.env.DISCORD_TOKEN);