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

const Reviews = db.reviews;

const Servers = db.servers;

const Votes = db.votes;

const ReviewsData = [
  {
    title: 'Amazing SkyBlock Experience',

    content:
      'The challenges are well-designed and the community is very supportive.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    status: 'submitted',
  },

  {
    title: 'Factions Kingdom Review',

    content:
      'Intense battles and strategic gameplay make this server a must-try.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    status: 'published',
  },

  {
    title: 'Creative World Insights',

    content: 'A perfect place for builders to showcase their skills.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    status: 'draft',
  },

  {
    title: 'Survival Haven Overview',

    content: 'A challenging yet rewarding experience for survival enthusiasts.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    status: 'draft',
  },

  {
    title: 'MiniGames Arena Fun',

    content: 'Endless fun with a variety of mini-games to choose from.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    status: 'published',
  },
];

const ServersData = [
  {
    name: 'SkyBlock Paradise',

    description:
      'A unique SkyBlock experience with custom challenges and rewards.',

    // type code here for "relation_many" field

    // type code here for "relation_many" field
  },

  {
    name: 'Factions Kingdom',

    description:
      'Join a faction, build your base, and conquer others in this competitive server.',

    // type code here for "relation_many" field

    // type code here for "relation_many" field
  },

  {
    name: 'Creative World',

    description:
      'Unleash your creativity with unlimited resources and plot protection.',

    // type code here for "relation_many" field

    // type code here for "relation_many" field
  },

  {
    name: 'Survival Haven',

    description:
      'Survive and thrive in a challenging environment with a friendly community.',

    // type code here for "relation_many" field

    // type code here for "relation_many" field
  },

  {
    name: 'MiniGames Arena',

    description:
      'Compete in various mini-games and earn rewards for your victories.',

    // type code here for "relation_many" field

    // type code here for "relation_many" field
  },
];

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

    // type code here for "relation_one" field

    voted_at: new Date('2023-10-01T10:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    voted_at: new Date('2023-10-01T11:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    voted_at: new Date('2023-10-01T12:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    voted_at: new Date('2023-10-01T13:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    voted_at: new Date('2023-10-01T14:00:00Z'),
  },
];

// Similar logic for "relation_many"

async function associateReviewWithServer() {
  const relatedServer0 = await Servers.findOne({
    offset: Math.floor(Math.random() * (await Servers.count())),
  });
  const Review0 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Review0?.setServer) {
    await Review0.setServer(relatedServer0);
  }

  const relatedServer1 = await Servers.findOne({
    offset: Math.floor(Math.random() * (await Servers.count())),
  });
  const Review1 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Review1?.setServer) {
    await Review1.setServer(relatedServer1);
  }

  const relatedServer2 = await Servers.findOne({
    offset: Math.floor(Math.random() * (await Servers.count())),
  });
  const Review2 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Review2?.setServer) {
    await Review2.setServer(relatedServer2);
  }

  const relatedServer3 = await Servers.findOne({
    offset: Math.floor(Math.random() * (await Servers.count())),
  });
  const Review3 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Review3?.setServer) {
    await Review3.setServer(relatedServer3);
  }

  const relatedServer4 = await Servers.findOne({
    offset: Math.floor(Math.random() * (await Servers.count())),
  });
  const Review4 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Review4?.setServer) {
    await Review4.setServer(relatedServer4);
  }
}

async function associateReviewWithAuthor() {
  const relatedAuthor0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review0 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Review0?.setAuthor) {
    await Review0.setAuthor(relatedAuthor0);
  }

  const relatedAuthor1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review1 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Review1?.setAuthor) {
    await Review1.setAuthor(relatedAuthor1);
  }

  const relatedAuthor2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review2 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Review2?.setAuthor) {
    await Review2.setAuthor(relatedAuthor2);
  }

  const relatedAuthor3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review3 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Review3?.setAuthor) {
    await Review3.setAuthor(relatedAuthor3);
  }

  const relatedAuthor4 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review4 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Review4?.setAuthor) {
    await Review4.setAuthor(relatedAuthor4);
  }
}

// Similar logic for "relation_many"

// Similar logic for "relation_many"

async function associateVoteWithServer() {
  const relatedServer0 = await Servers.findOne({
    offset: Math.floor(Math.random() * (await Servers.count())),
  });
  const Vote0 = await Votes.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Vote0?.setServer) {
    await Vote0.setServer(relatedServer0);
  }

  const relatedServer1 = await Servers.findOne({
    offset: Math.floor(Math.random() * (await Servers.count())),
  });
  const Vote1 = await Votes.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Vote1?.setServer) {
    await Vote1.setServer(relatedServer1);
  }

  const relatedServer2 = await Servers.findOne({
    offset: Math.floor(Math.random() * (await Servers.count())),
  });
  const Vote2 = await Votes.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Vote2?.setServer) {
    await Vote2.setServer(relatedServer2);
  }

  const relatedServer3 = await Servers.findOne({
    offset: Math.floor(Math.random() * (await Servers.count())),
  });
  const Vote3 = await Votes.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Vote3?.setServer) {
    await Vote3.setServer(relatedServer3);
  }

  const relatedServer4 = await Servers.findOne({
    offset: Math.floor(Math.random() * (await Servers.count())),
  });
  const Vote4 = await Votes.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Vote4?.setServer) {
    await Vote4.setServer(relatedServer4);
  }
}

async function associateVoteWithUser() {
  const relatedUser0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Vote0 = await Votes.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Vote0?.setUser) {
    await Vote0.setUser(relatedUser0);
  }

  const relatedUser1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Vote1 = await Votes.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Vote1?.setUser) {
    await Vote1.setUser(relatedUser1);
  }

  const relatedUser2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Vote2 = await Votes.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Vote2?.setUser) {
    await Vote2.setUser(relatedUser2);
  }

  const relatedUser3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Vote3 = await Votes.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Vote3?.setUser) {
    await Vote3.setUser(relatedUser3);
  }

  const relatedUser4 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Vote4 = await Votes.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Vote4?.setUser) {
    await Vote4.setUser(relatedUser4);
  }
}

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

    await Servers.bulkCreate(ServersData);

    await Votes.bulkCreate(VotesData);

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

      await associateReviewWithServer(),

      await associateReviewWithAuthor(),

      // Similar logic for "relation_many"

      // Similar logic for "relation_many"

      await associateVoteWithServer(),

      await associateVoteWithUser(),
    ]);
  },

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

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

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