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

const Billers = db.billers;

const Transactions = db.transactions;

const BillersData = [
  {
    name: 'Acme Corp',

    contact_email: 'contact@acmecorp.com',

    phone_number: '123-456-7890',
  },

  {
    name: 'Globex Inc',

    contact_email: 'info@globex.com',

    phone_number: '234-567-8901',
  },

  {
    name: 'Initech',

    contact_email: 'support@initech.com',

    phone_number: '345-678-9012',
  },

  {
    name: 'Umbrella Corp',

    contact_email: 'sales@umbrella.com',

    phone_number: '456-789-0123',
  },

  {
    name: 'Hooli',

    contact_email: 'hello@hooli.com',

    phone_number: '567-890-1234',
  },
];

const TransactionsData = [
  {
    transaction_id: 'TXN001',

    amount: 1500.75,

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

    // type code here for "relation_one" field

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

  {
    transaction_id: 'TXN002',

    amount: 250,

    transaction_date: new Date('2023-10-02T11:30:00Z'),

    // type code here for "relation_one" field

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

  {
    transaction_id: 'TXN003',

    amount: 500.5,

    transaction_date: new Date('2023-10-03T14:45:00Z'),

    // type code here for "relation_one" field

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

  {
    transaction_id: 'TXN004',

    amount: 750,

    transaction_date: new Date('2023-10-04T09:15:00Z'),

    // type code here for "relation_one" field

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

  {
    transaction_id: 'TXN005',

    amount: 1200,

    transaction_date: new Date('2023-10-05T16:00:00Z'),

    // type code here for "relation_one" field

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

// Similar logic for "relation_many"

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

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

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

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

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

async function associateTransactionWithBiller() {
  const relatedBiller0 = await Billers.findOne({
    offset: Math.floor(Math.random() * (await Billers.count())),
  });
  const Transaction0 = await Transactions.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Transaction0?.setBiller) {
    await Transaction0.setBiller(relatedBiller0);
  }

  const relatedBiller1 = await Billers.findOne({
    offset: Math.floor(Math.random() * (await Billers.count())),
  });
  const Transaction1 = await Transactions.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Transaction1?.setBiller) {
    await Transaction1.setBiller(relatedBiller1);
  }

  const relatedBiller2 = await Billers.findOne({
    offset: Math.floor(Math.random() * (await Billers.count())),
  });
  const Transaction2 = await Transactions.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Transaction2?.setBiller) {
    await Transaction2.setBiller(relatedBiller2);
  }

  const relatedBiller3 = await Billers.findOne({
    offset: Math.floor(Math.random() * (await Billers.count())),
  });
  const Transaction3 = await Transactions.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Transaction3?.setBiller) {
    await Transaction3.setBiller(relatedBiller3);
  }

  const relatedBiller4 = await Billers.findOne({
    offset: Math.floor(Math.random() * (await Billers.count())),
  });
  const Transaction4 = await Transactions.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Transaction4?.setBiller) {
    await Transaction4.setBiller(relatedBiller4);
  }
}

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

    await Transactions.bulkCreate(TransactionsData);

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

      await associateTransactionWithUser(),

      await associateTransactionWithBiller(),
    ]);
  },

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

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