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

const Departments = db.departments;

const Employees = db.employees;

const DepartmentsData = [
  {
    name: 'Sales',

    // type code here for "relation_one" field

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

  {
    name: 'Marketing',

    // type code here for "relation_one" field

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

  {
    name: 'IT',

    // type code here for "relation_one" field

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

  {
    name: 'HR',

    // type code here for "relation_one" field

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

  {
    name: 'Finance',

    // type code here for "relation_one" field

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

const EmployeesData = [
  {
    first_name: 'John',

    last_name: 'Doe',

    email: 'john.doe@example.com',

    hire_date: new Date('2023-01-15'),

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

  {
    first_name: 'Jane',

    last_name: 'Roe',

    email: 'jane.roe@example.com',

    hire_date: new Date('2022-11-20'),

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

  {
    first_name: 'Jim',

    last_name: 'Beam',

    email: 'jim.beam@example.com',

    hire_date: new Date('2023-03-10'),

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

  {
    first_name: 'Jill',

    last_name: 'Valentine',

    email: 'jill.valentine@example.com',

    hire_date: new Date('2023-05-05'),

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

  {
    first_name: 'Jack',

    last_name: 'Sparrow',

    email: 'jack.sparrow@example.com',

    hire_date: new Date('2023-07-25'),

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

// Similar logic for "relation_many"

async function associateDepartmentWithLeader() {
  const relatedLeader0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Department0 = await Departments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Department0?.setLeader) {
    await Department0.setLeader(relatedLeader0);
  }

  const relatedLeader1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Department1 = await Departments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Department1?.setLeader) {
    await Department1.setLeader(relatedLeader1);
  }

  const relatedLeader2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Department2 = await Departments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Department2?.setLeader) {
    await Department2.setLeader(relatedLeader2);
  }

  const relatedLeader3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Department3 = await Departments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Department3?.setLeader) {
    await Department3.setLeader(relatedLeader3);
  }

  const relatedLeader4 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Department4 = await Departments.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Department4?.setLeader) {
    await Department4.setLeader(relatedLeader4);
  }
}

// Similar logic for "relation_many"

async function associateEmployeeWithDepartment() {
  const relatedDepartment0 = await Departments.findOne({
    offset: Math.floor(Math.random() * (await Departments.count())),
  });
  const Employee0 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Employee0?.setDepartment) {
    await Employee0.setDepartment(relatedDepartment0);
  }

  const relatedDepartment1 = await Departments.findOne({
    offset: Math.floor(Math.random() * (await Departments.count())),
  });
  const Employee1 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Employee1?.setDepartment) {
    await Employee1.setDepartment(relatedDepartment1);
  }

  const relatedDepartment2 = await Departments.findOne({
    offset: Math.floor(Math.random() * (await Departments.count())),
  });
  const Employee2 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Employee2?.setDepartment) {
    await Employee2.setDepartment(relatedDepartment2);
  }

  const relatedDepartment3 = await Departments.findOne({
    offset: Math.floor(Math.random() * (await Departments.count())),
  });
  const Employee3 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Employee3?.setDepartment) {
    await Employee3.setDepartment(relatedDepartment3);
  }

  const relatedDepartment4 = await Departments.findOne({
    offset: Math.floor(Math.random() * (await Departments.count())),
  });
  const Employee4 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Employee4?.setDepartment) {
    await Employee4.setDepartment(relatedDepartment4);
  }
}

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

    await Employees.bulkCreate(EmployeesData);

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

      await associateDepartmentWithLeader(),

      // Similar logic for "relation_many"

      await associateEmployeeWithDepartment(),
    ]);
  },

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

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