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

const Commissions = db.commissions;

const Investments = db.investments;

const Loans = db.loans;

const Meetings = db.meetings;

const Projects = db.projects;

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

    // type code here for "relation_one" field

    amount: 200,

    date_earned: new Date('2023-11-06T00:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    amount: 150,

    date_earned: new Date('2023-11-11T00:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    amount: 100,

    date_earned: new Date('2023-10-21T00:00:00Z'),
  },
];

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

    // type code here for "relation_one" field

    amount: 5000,

    status: 'failed',

    investment_date: new Date('2023-11-05T00:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    amount: 10000,

    status: 'failed',

    investment_date: new Date('2023-11-10T00:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    amount: 7500,

    status: 'failed',

    investment_date: new Date('2023-10-20T00:00:00Z'),
  },
];

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

    amount: 20000,

    status: 'approved',

    application_date: new Date('2023-11-01T00:00:00Z'),

    due_date: new Date('2024-11-01T00:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    amount: 15000,

    status: 'approved',

    application_date: new Date('2023-11-05T00:00:00Z'),

    due_date: new Date('2024-11-05T00:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    amount: 10000,

    status: 'pending',

    application_date: new Date('2023-11-10T00:00:00Z'),

    due_date: new Date('2024-11-10T00:00:00Z'),
  },
];

const MeetingsData = [
  {
    topic: 'Investment Strategies 2024',

    scheduled_date: new Date('2023-12-05T00:00:00Z'),

    // type code here for "relation_many" field

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

  {
    topic: 'Debt Recovery Techniques',

    scheduled_date: new Date('2023-12-10T00:00:00Z'),

    // type code here for "relation_many" field

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

  {
    topic: 'Community Engagement',

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

    // type code here for "relation_many" field

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

const ProjectsData = [
  {
    title: 'Green Energy Bonds',

    annual_rate: 5.5,

    remaining_quota: 100000,

    status: 'in_progress',

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

    end_date: new Date('2024-11-01T00:00:00Z'),

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

  {
    title: 'Tech Startup Equity',

    annual_rate: 8,

    remaining_quota: 50000,

    status: 'closed',

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

    end_date: new Date('2024-10-15T00:00:00Z'),

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

  {
    title: 'Real Estate Fund',

    annual_rate: 6.5,

    remaining_quota: 75000,

    status: 'closed',

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

    end_date: new Date('2024-09-01T00:00:00Z'),

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

// Similar logic for "relation_many"

async function associateCommissionWithReferrer() {
  const relatedReferrer0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Commission0 = await Commissions.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Commission0?.setReferrer) {
    await Commission0.setReferrer(relatedReferrer0);
  }

  const relatedReferrer1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Commission1 = await Commissions.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Commission1?.setReferrer) {
    await Commission1.setReferrer(relatedReferrer1);
  }

  const relatedReferrer2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Commission2 = await Commissions.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Commission2?.setReferrer) {
    await Commission2.setReferrer(relatedReferrer2);
  }
}

async function associateCommissionWithReferred_user() {
  const relatedReferred_user0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Commission0 = await Commissions.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Commission0?.setReferred_user) {
    await Commission0.setReferred_user(relatedReferred_user0);
  }

  const relatedReferred_user1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Commission1 = await Commissions.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Commission1?.setReferred_user) {
    await Commission1.setReferred_user(relatedReferred_user1);
  }

  const relatedReferred_user2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Commission2 = await Commissions.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Commission2?.setReferred_user) {
    await Commission2.setReferred_user(relatedReferred_user2);
  }
}

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

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

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

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

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

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

async function associateLoanWithBorrower() {
  const relatedBorrower0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Loan0 = await Loans.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Loan0?.setBorrower) {
    await Loan0.setBorrower(relatedBorrower0);
  }

  const relatedBorrower1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Loan1 = await Loans.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Loan1?.setBorrower) {
    await Loan1.setBorrower(relatedBorrower1);
  }

  const relatedBorrower2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Loan2 = await Loans.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Loan2?.setBorrower) {
    await Loan2.setBorrower(relatedBorrower2);
  }
}

// Similar logic for "relation_many"

async function associateMeetingWithHost() {
  const relatedHost0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Meeting0 = await Meetings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Meeting0?.setHost) {
    await Meeting0.setHost(relatedHost0);
  }

  const relatedHost1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Meeting1 = await Meetings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Meeting1?.setHost) {
    await Meeting1.setHost(relatedHost1);
  }

  const relatedHost2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Meeting2 = await Meetings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Meeting2?.setHost) {
    await Meeting2.setHost(relatedHost2);
  }
}

// Similar logic for "relation_many"

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

    await Investments.bulkCreate(InvestmentsData);

    await Loans.bulkCreate(LoansData);

    await Meetings.bulkCreate(MeetingsData);

    await Projects.bulkCreate(ProjectsData);

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

      await associateCommissionWithReferrer(),

      await associateCommissionWithReferred_user(),

      await associateInvestmentWithUser(),

      await associateInvestmentWithProject(),

      await associateLoanWithBorrower(),

      // Similar logic for "relation_many"

      await associateMeetingWithHost(),

      // Similar logic for "relation_many"
    ]);
  },

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

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

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

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

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