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

const Credits = db.credits;

const Files = db.files;

const Projects = db.projects;

const Organizations = db.organizations;

const CreditsData = [
  {
    name: 'Indoor Water Use Reduction',

    type: 'OptimizeEnergyPerformance',

    // type code here for "relation_one" field

    // type code here for "relation_many" field

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

  {
    name: 'Interior Lighting',

    type: 'OptimizeEnergyPerformance',

    // type code here for "relation_one" field

    // type code here for "relation_many" field

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

  {
    name: 'Optimize Energy Performance',

    type: 'InteriorLighting',

    // type code here for "relation_one" field

    // type code here for "relation_many" field

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

  {
    name: 'Water Efficiency',

    type: 'IndoorWaterUseReduction',

    // type code here for "relation_one" field

    // type code here for "relation_many" field

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

  {
    name: 'Energy Optimization',

    type: 'OptimizeEnergyPerformance',

    // type code here for "relation_one" field

    // type code here for "relation_many" field

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

const FilesData = [
  {
    file_name: 'water_use_data.xlsx',

    // type code here for "files" field

    // type code here for "relation_one" field

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

  {
    file_name: 'lighting_plan.pdf',

    // type code here for "files" field

    // type code here for "relation_one" field

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

  {
    file_name: 'energy_performance_report.docx',

    // type code here for "files" field

    // type code here for "relation_one" field

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

  {
    file_name: 'water_efficiency_schedule.xlsx',

    // type code here for "files" field

    // type code here for "relation_one" field

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

  {
    file_name: 'energy_optimization_summary.pdf',

    // type code here for "files" field

    // type code here for "relation_one" field

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

const ProjectsData = [
  {
    name: 'Riverstone Tower',

    start_date: new Date('2023-01-15T00:00:00Z'),

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

    // type code here for "relation_one" field

    // type code here for "relation_many" field

    // type code here for "relation_many" field

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

  {
    name: 'Eco Park Complex',

    start_date: new Date('2023-02-01T00:00:00Z'),

    end_date: new Date('2023-11-30T00:00:00Z'),

    // type code here for "relation_one" field

    // type code here for "relation_many" field

    // type code here for "relation_many" field

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

  {
    name: 'Green Valley Residences',

    start_date: new Date('2023-03-10T00:00:00Z'),

    end_date: new Date('2023-10-20T00:00:00Z'),

    // type code here for "relation_one" field

    // type code here for "relation_many" field

    // type code here for "relation_many" field

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

  {
    name: 'Sustainable Office Hub',

    start_date: new Date('2023-04-05T00:00:00Z'),

    end_date: new Date('2023-09-25T00:00:00Z'),

    // type code here for "relation_one" field

    // type code here for "relation_many" field

    // type code here for "relation_many" field

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

  {
    name: 'LEED Platinum School',

    start_date: new Date('2023-05-20T00:00:00Z'),

    end_date: new Date('2023-08-15T00:00:00Z'),

    // type code here for "relation_one" field

    // type code here for "relation_many" field

    // type code here for "relation_many" field

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

const OrganizationsData = [
  {
    name: 'Green Consult Ltd.',
  },

  {
    name: 'Eco Builders Inc.',
  },

  {
    name: 'Sustainable Solutions',
  },

  {
    name: 'LEED Experts',
  },

  {
    name: 'Green Future Group',
  },
];

// Similar logic for "relation_many"

async function associateUserWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User0 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (User0?.setOrganization) {
    await User0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User1 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (User1?.setOrganization) {
    await User1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User2 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (User2?.setOrganization) {
    await User2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User3 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (User3?.setOrganization) {
    await User3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User4 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (User4?.setOrganization) {
    await User4.setOrganization(relatedOrganization4);
  }
}

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

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

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

  const relatedProject3 = await Projects.findOne({
    offset: Math.floor(Math.random() * (await Projects.count())),
  });
  const Credit3 = await Credits.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Credit3?.setProject) {
    await Credit3.setProject(relatedProject3);
  }

  const relatedProject4 = await Projects.findOne({
    offset: Math.floor(Math.random() * (await Projects.count())),
  });
  const Credit4 = await Credits.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Credit4?.setProject) {
    await Credit4.setProject(relatedProject4);
  }
}

// Similar logic for "relation_many"

async function associateCreditWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Credit0 = await Credits.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Credit0?.setOrganization) {
    await Credit0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Credit1 = await Credits.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Credit1?.setOrganization) {
    await Credit1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Credit2 = await Credits.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Credit2?.setOrganization) {
    await Credit2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Credit3 = await Credits.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Credit3?.setOrganization) {
    await Credit3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Credit4 = await Credits.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Credit4?.setOrganization) {
    await Credit4.setOrganization(relatedOrganization4);
  }
}

async function associateFileWithCredit() {
  const relatedCredit0 = await Credits.findOne({
    offset: Math.floor(Math.random() * (await Credits.count())),
  });
  const File0 = await Files.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (File0?.setCredit) {
    await File0.setCredit(relatedCredit0);
  }

  const relatedCredit1 = await Credits.findOne({
    offset: Math.floor(Math.random() * (await Credits.count())),
  });
  const File1 = await Files.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (File1?.setCredit) {
    await File1.setCredit(relatedCredit1);
  }

  const relatedCredit2 = await Credits.findOne({
    offset: Math.floor(Math.random() * (await Credits.count())),
  });
  const File2 = await Files.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (File2?.setCredit) {
    await File2.setCredit(relatedCredit2);
  }

  const relatedCredit3 = await Credits.findOne({
    offset: Math.floor(Math.random() * (await Credits.count())),
  });
  const File3 = await Files.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (File3?.setCredit) {
    await File3.setCredit(relatedCredit3);
  }

  const relatedCredit4 = await Credits.findOne({
    offset: Math.floor(Math.random() * (await Credits.count())),
  });
  const File4 = await Files.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (File4?.setCredit) {
    await File4.setCredit(relatedCredit4);
  }
}

async function associateFileWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const File0 = await Files.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (File0?.setOrganization) {
    await File0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const File1 = await Files.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (File1?.setOrganization) {
    await File1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const File2 = await Files.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (File2?.setOrganization) {
    await File2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const File3 = await Files.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (File3?.setOrganization) {
    await File3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const File4 = await Files.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (File4?.setOrganization) {
    await File4.setOrganization(relatedOrganization4);
  }
}

async function associateProjectWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Project0 = await Projects.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Project0?.setOrganization) {
    await Project0.setOrganization(relatedOrganization0);
  }

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

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

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Project3 = await Projects.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Project3?.setOrganization) {
    await Project3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Project4 = await Projects.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Project4?.setOrganization) {
    await Project4.setOrganization(relatedOrganization4);
  }
}

// Similar logic for "relation_many"

// Similar logic for "relation_many"

async function associateProjectWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Project0 = await Projects.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Project0?.setOrganization) {
    await Project0.setOrganization(relatedOrganization0);
  }

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

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

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Project3 = await Projects.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Project3?.setOrganization) {
    await Project3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Project4 = await Projects.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Project4?.setOrganization) {
    await Project4.setOrganization(relatedOrganization4);
  }
}

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

    await Files.bulkCreate(FilesData);

    await Projects.bulkCreate(ProjectsData);

    await Organizations.bulkCreate(OrganizationsData);

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

      await associateUserWithOrganization(),

      await associateCreditWithProject(),

      // Similar logic for "relation_many"

      await associateCreditWithOrganization(),

      await associateFileWithCredit(),

      await associateFileWithOrganization(),

      await associateProjectWithOrganization(),

      // Similar logic for "relation_many"

      // Similar logic for "relation_many"

      await associateProjectWithOrganization(),
    ]);
  },

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

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

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

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