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

const Budgets = db.budgets;

const Expenses = db.expenses;

const Reports = db.reports;

const BudgetsData = [
  {
    category: 'Entertainment',

    amount: 300,

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

  {
    category: 'Entertainment',

    amount: 100,

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

  {
    category: 'Others',

    amount: 200,

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

  {
    category: 'Food',

    amount: 150,

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

  {
    category: 'Entertainment',

    amount: 50,

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

const ExpensesData = [
  {
    description: 'Grocery shopping',

    amount: 150.75,

    category: 'Food',

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

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

  {
    description: 'Monthly subway pass',

    amount: 50,

    category: 'Transport',

    date: new Date('2023-10-02T08:30:00Z'),

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

  {
    description: 'Electricity bill',

    amount: 75.2,

    category: 'Food',

    date: new Date('2023-10-03T12:00:00Z'),

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

  {
    description: 'Movie night',

    amount: 30,

    category: 'Entertainment',

    date: new Date('2023-10-04T19:00:00Z'),

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

  {
    description: 'Coffee with friends',

    amount: 20,

    category: 'Utilities',

    date: new Date('2023-10-05T15:00:00Z'),

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

const ReportsData = [
  {
    start_date: new Date('2023-10-01T00:00:00Z'),

    end_date: new Date('2023-10-31T23:59:59Z'),

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

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

    end_date: new Date('2023-09-30T23:59:59Z'),

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

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

    end_date: new Date('2023-08-31T23:59:59Z'),

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

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

    end_date: new Date('2023-07-31T23:59:59Z'),

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

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

    end_date: new Date('2023-06-30T23:59:59Z'),

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

// Similar logic for "relation_many"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    await Expenses.bulkCreate(ExpensesData);

    await Reports.bulkCreate(ReportsData);

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

      await associateBudgetWithUser(),

      await associateExpenseWithUser(),

      await associateReportWithUser(),
    ]);
  },

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

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

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