const db = require('../models');
const Users = db.users;

const Games = db.games;

const ProgressReports = db.progress_reports;

const GamesData = [
  {
    date_played: new Date('2023-10-01T14:30:00Z'),

    result: 'win',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    score: 100,
  },

  {
    date_played: new Date('2023-10-02T15:00:00Z'),

    result: 'win',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    score: 85,
  },

  {
    date_played: new Date('2023-10-03T16:00:00Z'),

    result: 'win',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    score: 95,
  },

  {
    date_played: new Date('2023-10-04T17:00:00Z'),

    result: 'win',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    score: 70,
  },

  {
    date_played: new Date('2023-10-05T18:00:00Z'),

    result: 'loss',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    score: 110,
  },
];

const ProgressReportsData = [
  {
    // type code here for "relation_one" field

    total_wins: 3,

    total_losses: 2,

    win_rate: 60,
  },

  {
    // type code here for "relation_one" field

    total_wins: 2,

    total_losses: 3,

    win_rate: 40,
  },

  {
    // type code here for "relation_one" field

    total_wins: 0,

    total_losses: 0,

    win_rate: 0,
  },

  {
    // type code here for "relation_one" field

    total_wins: 0,

    total_losses: 0,

    win_rate: 0,
  },

  {
    // type code here for "relation_one" field

    total_wins: 0,

    total_losses: 0,

    win_rate: 0,
  },
];

// Similar logic for "relation_many"

async function associateGameWithPlayer() {
  const relatedPlayer0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Game0 = await Games.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Game0?.setPlayer) {
    await Game0.setPlayer(relatedPlayer0);
  }

  const relatedPlayer1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Game1 = await Games.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Game1?.setPlayer) {
    await Game1.setPlayer(relatedPlayer1);
  }

  const relatedPlayer2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Game2 = await Games.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Game2?.setPlayer) {
    await Game2.setPlayer(relatedPlayer2);
  }

  const relatedPlayer3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Game3 = await Games.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Game3?.setPlayer) {
    await Game3.setPlayer(relatedPlayer3);
  }

  const relatedPlayer4 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Game4 = await Games.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Game4?.setPlayer) {
    await Game4.setPlayer(relatedPlayer4);
  }
}

async function associateGameWithOpponent() {
  const relatedOpponent0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Game0 = await Games.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Game0?.setOpponent) {
    await Game0.setOpponent(relatedOpponent0);
  }

  const relatedOpponent1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Game1 = await Games.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Game1?.setOpponent) {
    await Game1.setOpponent(relatedOpponent1);
  }

  const relatedOpponent2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Game2 = await Games.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Game2?.setOpponent) {
    await Game2.setOpponent(relatedOpponent2);
  }

  const relatedOpponent3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Game3 = await Games.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Game3?.setOpponent) {
    await Game3.setOpponent(relatedOpponent3);
  }

  const relatedOpponent4 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Game4 = await Games.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Game4?.setOpponent) {
    await Game4.setOpponent(relatedOpponent4);
  }
}

async function associateProgressReportWithPlayer() {
  const relatedPlayer0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const ProgressReport0 = await ProgressReports.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ProgressReport0?.setPlayer) {
    await ProgressReport0.setPlayer(relatedPlayer0);
  }

  const relatedPlayer1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const ProgressReport1 = await ProgressReports.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ProgressReport1?.setPlayer) {
    await ProgressReport1.setPlayer(relatedPlayer1);
  }

  const relatedPlayer2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const ProgressReport2 = await ProgressReports.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ProgressReport2?.setPlayer) {
    await ProgressReport2.setPlayer(relatedPlayer2);
  }

  const relatedPlayer3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const ProgressReport3 = await ProgressReports.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (ProgressReport3?.setPlayer) {
    await ProgressReport3.setPlayer(relatedPlayer3);
  }

  const relatedPlayer4 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const ProgressReport4 = await ProgressReports.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (ProgressReport4?.setPlayer) {
    await ProgressReport4.setPlayer(relatedPlayer4);
  }
}

module.exports = {
  up: async (queryInterface, Sequelize) => {
    await Games.bulkCreate(GamesData);

    await ProgressReports.bulkCreate(ProgressReportsData);

    await Promise.all([
      // Similar logic for "relation_many"

      await associateGameWithPlayer(),

      await associateGameWithOpponent(),

      await associateProgressReportWithPlayer(),
    ]);
  },

  down: async (queryInterface, Sequelize) => {
    await queryInterface.bulkDelete('games', null, {});

    await queryInterface.bulkDelete('progress_reports', null, {});
  },
};