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

const Idos = db.idos;

const Launchpads = db.launchpads;

const Projects = db.projects;

const IdosData = [
  {
    name: 'CryptoCoin',

    start_date: new Date('2023-11-01T10:00:00Z'),

    end_date: new Date('2023-11-10T10:00:00Z'),

    token_price: 0.05,

    raise_amount: 1000000,

    status: 'completed',

    // type code here for "relation_one" field

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

  {
    name: 'TechGadget',

    start_date: new Date('2023-12-01T10:00:00Z'),

    end_date: new Date('2023-12-15T10:00:00Z'),

    token_price: 0.1,

    raise_amount: 500000,

    status: 'completed',

    // type code here for "relation_one" field

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

  {
    name: 'GreenToken',

    start_date: new Date('2023-11-15T10:00:00Z'),

    end_date: new Date('2023-11-25T10:00:00Z'),

    token_price: 0.07,

    raise_amount: 750000,

    status: 'completed',

    // type code here for "relation_one" field

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

const LaunchpadsData = [
  {
    name: 'CryptoLaunch',

    description: 'A platform for launching new crypto projects.',

    // type code here for "relation_many" field

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

  {
    name: 'TechStart',

    description: 'Launchpad for tech startups.',

    // type code here for "relation_many" field

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

  {
    name: 'GreenEnergy',

    description: 'Platform for green energy projects.',

    // type code here for "relation_many" field

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

const ProjectsData = [
  {
    name: 'Crypto Revolution',

    description: 'A revolutionary crypto project.',

    token_name: 'CRYPTO',

    // type code here for "relation_many" field

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

  {
    name: 'Tech Innovators',

    description: 'Innovative tech solutions.',

    token_name: 'TECH',

    // type code here for "relation_many" field

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

  {
    name: 'Green Future',

    description: 'Sustainable energy solutions.',

    token_name: 'GREEN',

    // type code here for "relation_many" field

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

// Similar logic for "relation_many"

async function associateIdoWithLaunchpad() {
  const relatedLaunchpad0 = await Launchpads.findOne({
    offset: Math.floor(Math.random() * (await Launchpads.count())),
  });
  const Ido0 = await Idos.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Ido0?.setLaunchpad) {
    await Ido0.setLaunchpad(relatedLaunchpad0);
  }

  const relatedLaunchpad1 = await Launchpads.findOne({
    offset: Math.floor(Math.random() * (await Launchpads.count())),
  });
  const Ido1 = await Idos.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Ido1?.setLaunchpad) {
    await Ido1.setLaunchpad(relatedLaunchpad1);
  }

  const relatedLaunchpad2 = await Launchpads.findOne({
    offset: Math.floor(Math.random() * (await Launchpads.count())),
  });
  const Ido2 = await Idos.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Ido2?.setLaunchpad) {
    await Ido2.setLaunchpad(relatedLaunchpad2);
  }
}

async function associateIdoWithProject() {
  const relatedProject0 = await Projects.findOne({
    offset: Math.floor(Math.random() * (await Projects.count())),
  });
  const Ido0 = await Idos.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Ido0?.setProject) {
    await Ido0.setProject(relatedProject0);
  }

  const relatedProject1 = await Projects.findOne({
    offset: Math.floor(Math.random() * (await Projects.count())),
  });
  const Ido1 = await Idos.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Ido1?.setProject) {
    await Ido1.setProject(relatedProject1);
  }

  const relatedProject2 = await Projects.findOne({
    offset: Math.floor(Math.random() * (await Projects.count())),
  });
  const Ido2 = await Idos.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Ido2?.setProject) {
    await Ido2.setProject(relatedProject2);
  }
}

// Similar logic for "relation_many"

async function associateLaunchpadWithOwner() {
  const relatedOwner0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Launchpad0 = await Launchpads.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Launchpad0?.setOwner) {
    await Launchpad0.setOwner(relatedOwner0);
  }

  const relatedOwner1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Launchpad1 = await Launchpads.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Launchpad1?.setOwner) {
    await Launchpad1.setOwner(relatedOwner1);
  }

  const relatedOwner2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Launchpad2 = await Launchpads.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Launchpad2?.setOwner) {
    await Launchpad2.setOwner(relatedOwner2);
  }
}

// Similar logic for "relation_many"

async function associateProjectWithManager() {
  const relatedManager0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Project0 = await Projects.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Project0?.setManager) {
    await Project0.setManager(relatedManager0);
  }

  const relatedManager1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Project1 = await Projects.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Project1?.setManager) {
    await Project1.setManager(relatedManager1);
  }

  const relatedManager2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Project2 = await Projects.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Project2?.setManager) {
    await Project2.setManager(relatedManager2);
  }
}

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

    await Launchpads.bulkCreate(LaunchpadsData);

    await Projects.bulkCreate(ProjectsData);

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

      await associateIdoWithLaunchpad(),

      await associateIdoWithProject(),

      // Similar logic for "relation_many"

      await associateLaunchpadWithOwner(),

      // Similar logic for "relation_many"

      await associateProjectWithManager(),
    ]);
  },

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

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

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