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

const Appointments = db.appointments;

const Invoices = db.invoices;

const MedicalRecords = db.medical_records;

const Patients = db.patients;

const Tenants = db.tenants;

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

    // type code here for "relation_one" field

    start_time: new Date('2023-10-10T09:00:00Z'),

    end_time: new Date('2023-10-10T09:30:00Z'),

    // type code here for "relation_one" field

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

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    start_time: new Date('2023-10-11T10:00:00Z'),

    end_time: new Date('2023-10-11T10:30:00Z'),

    // type code here for "relation_one" field

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

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    start_time: new Date('2023-10-12T11:00:00Z'),

    end_time: new Date('2023-10-12T11:30:00Z'),

    // type code here for "relation_one" field

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

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    start_time: new Date('2023-10-13T12:00:00Z'),

    end_time: new Date('2023-10-13T12:30:00Z'),

    // type code here for "relation_one" field

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

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

    amount: 150,

    status: 'unpaid',

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

    // type code here for "relation_one" field

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

  {
    // type code here for "relation_one" field

    amount: 200,

    status: 'unpaid',

    issue_date: new Date('2023-09-05T00:00:00Z'),

    // type code here for "relation_one" field

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

  {
    // type code here for "relation_one" field

    amount: 250,

    status: 'paid',

    issue_date: new Date('2023-09-10T00:00:00Z'),

    // type code here for "relation_one" field

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

  {
    // type code here for "relation_one" field

    amount: 300,

    status: 'unpaid',

    issue_date: new Date('2023-09-15T00:00:00Z'),

    // type code here for "relation_one" field

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

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

    notes: 'Patient has a history of hypertension.',

    // type code here for "relation_one" field

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

  {
    // type code here for "relation_one" field

    notes: 'Patient is allergic to penicillin.',

    // type code here for "relation_one" field

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

  {
    // type code here for "relation_one" field

    notes: 'Patient requires regular check-ups for diabetes.',

    // type code here for "relation_one" field

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

  {
    // type code here for "relation_one" field

    notes: 'Patient has a family history of heart disease.',

    // type code here for "relation_one" field

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

const PatientsData = [
  {
    first_name: 'John',

    last_name: 'Doe',

    date_of_birth: new Date('1985-06-15T00:00:00Z'),

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

    // type code here for "relation_one" field

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

  {
    first_name: 'Jane',

    last_name: 'Smith',

    date_of_birth: new Date('1990-09-25T00:00:00Z'),

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

    // type code here for "relation_one" field

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

  {
    first_name: 'Emily',

    last_name: 'Johnson',

    date_of_birth: new Date('1978-03-12T00:00:00Z'),

    email: 'emily.johnson@example.com',

    // type code here for "relation_one" field

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

  {
    first_name: 'Michael',

    last_name: 'Brown',

    date_of_birth: new Date('1982-11-30T00:00:00Z'),

    email: 'michael.brown@example.com',

    // type code here for "relation_one" field

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

const TenantsData = [
  {
    name: 'Health Clinic A',
  },

  {
    name: 'Health Clinic B',
  },

  {
    name: 'Health Clinic C',
  },

  {
    name: 'Health Clinic D',
  },
];

// Similar logic for "relation_many"

async function associateUserWithTenant() {
  const relatedTenant0 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const User0 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (User0?.setTenant) {
    await User0.setTenant(relatedTenant0);
  }

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

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

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

async function associateAppointmentWithPatient() {
  const relatedPatient0 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const Appointment0 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Appointment0?.setPatient) {
    await Appointment0.setPatient(relatedPatient0);
  }

  const relatedPatient1 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const Appointment1 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Appointment1?.setPatient) {
    await Appointment1.setPatient(relatedPatient1);
  }

  const relatedPatient2 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const Appointment2 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Appointment2?.setPatient) {
    await Appointment2.setPatient(relatedPatient2);
  }

  const relatedPatient3 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const Appointment3 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Appointment3?.setPatient) {
    await Appointment3.setPatient(relatedPatient3);
  }
}

async function associateAppointmentWithHealth_professional() {
  const relatedHealth_professional0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Appointment0 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Appointment0?.setHealth_professional) {
    await Appointment0.setHealth_professional(relatedHealth_professional0);
  }

  const relatedHealth_professional1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Appointment1 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Appointment1?.setHealth_professional) {
    await Appointment1.setHealth_professional(relatedHealth_professional1);
  }

  const relatedHealth_professional2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Appointment2 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Appointment2?.setHealth_professional) {
    await Appointment2.setHealth_professional(relatedHealth_professional2);
  }

  const relatedHealth_professional3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Appointment3 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Appointment3?.setHealth_professional) {
    await Appointment3.setHealth_professional(relatedHealth_professional3);
  }
}

async function associateAppointmentWithTenant() {
  const relatedTenant0 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Appointment0 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Appointment0?.setTenant) {
    await Appointment0.setTenant(relatedTenant0);
  }

  const relatedTenant1 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Appointment1 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Appointment1?.setTenant) {
    await Appointment1.setTenant(relatedTenant1);
  }

  const relatedTenant2 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Appointment2 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Appointment2?.setTenant) {
    await Appointment2.setTenant(relatedTenant2);
  }

  const relatedTenant3 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Appointment3 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Appointment3?.setTenant) {
    await Appointment3.setTenant(relatedTenant3);
  }
}

async function associateAppointmentWithTenant() {
  const relatedTenant0 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Appointment0 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Appointment0?.setTenant) {
    await Appointment0.setTenant(relatedTenant0);
  }

  const relatedTenant1 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Appointment1 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Appointment1?.setTenant) {
    await Appointment1.setTenant(relatedTenant1);
  }

  const relatedTenant2 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Appointment2 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Appointment2?.setTenant) {
    await Appointment2.setTenant(relatedTenant2);
  }

  const relatedTenant3 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Appointment3 = await Appointments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Appointment3?.setTenant) {
    await Appointment3.setTenant(relatedTenant3);
  }
}

async function associateInvoiceWithPatient() {
  const relatedPatient0 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const Invoice0 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Invoice0?.setPatient) {
    await Invoice0.setPatient(relatedPatient0);
  }

  const relatedPatient1 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const Invoice1 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Invoice1?.setPatient) {
    await Invoice1.setPatient(relatedPatient1);
  }

  const relatedPatient2 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const Invoice2 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Invoice2?.setPatient) {
    await Invoice2.setPatient(relatedPatient2);
  }

  const relatedPatient3 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const Invoice3 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Invoice3?.setPatient) {
    await Invoice3.setPatient(relatedPatient3);
  }
}

async function associateInvoiceWithTenant() {
  const relatedTenant0 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Invoice0 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Invoice0?.setTenant) {
    await Invoice0.setTenant(relatedTenant0);
  }

  const relatedTenant1 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Invoice1 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Invoice1?.setTenant) {
    await Invoice1.setTenant(relatedTenant1);
  }

  const relatedTenant2 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Invoice2 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Invoice2?.setTenant) {
    await Invoice2.setTenant(relatedTenant2);
  }

  const relatedTenant3 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Invoice3 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Invoice3?.setTenant) {
    await Invoice3.setTenant(relatedTenant3);
  }
}

async function associateInvoiceWithTenant() {
  const relatedTenant0 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Invoice0 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Invoice0?.setTenant) {
    await Invoice0.setTenant(relatedTenant0);
  }

  const relatedTenant1 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Invoice1 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Invoice1?.setTenant) {
    await Invoice1.setTenant(relatedTenant1);
  }

  const relatedTenant2 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Invoice2 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Invoice2?.setTenant) {
    await Invoice2.setTenant(relatedTenant2);
  }

  const relatedTenant3 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Invoice3 = await Invoices.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Invoice3?.setTenant) {
    await Invoice3.setTenant(relatedTenant3);
  }
}

async function associateMedicalRecordWithPatient() {
  const relatedPatient0 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const MedicalRecord0 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (MedicalRecord0?.setPatient) {
    await MedicalRecord0.setPatient(relatedPatient0);
  }

  const relatedPatient1 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const MedicalRecord1 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (MedicalRecord1?.setPatient) {
    await MedicalRecord1.setPatient(relatedPatient1);
  }

  const relatedPatient2 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const MedicalRecord2 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (MedicalRecord2?.setPatient) {
    await MedicalRecord2.setPatient(relatedPatient2);
  }

  const relatedPatient3 = await Patients.findOne({
    offset: Math.floor(Math.random() * (await Patients.count())),
  });
  const MedicalRecord3 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (MedicalRecord3?.setPatient) {
    await MedicalRecord3.setPatient(relatedPatient3);
  }
}

async function associateMedicalRecordWithTenant() {
  const relatedTenant0 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const MedicalRecord0 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (MedicalRecord0?.setTenant) {
    await MedicalRecord0.setTenant(relatedTenant0);
  }

  const relatedTenant1 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const MedicalRecord1 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (MedicalRecord1?.setTenant) {
    await MedicalRecord1.setTenant(relatedTenant1);
  }

  const relatedTenant2 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const MedicalRecord2 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (MedicalRecord2?.setTenant) {
    await MedicalRecord2.setTenant(relatedTenant2);
  }

  const relatedTenant3 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const MedicalRecord3 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (MedicalRecord3?.setTenant) {
    await MedicalRecord3.setTenant(relatedTenant3);
  }
}

async function associateMedicalRecordWithTenant() {
  const relatedTenant0 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const MedicalRecord0 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (MedicalRecord0?.setTenant) {
    await MedicalRecord0.setTenant(relatedTenant0);
  }

  const relatedTenant1 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const MedicalRecord1 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (MedicalRecord1?.setTenant) {
    await MedicalRecord1.setTenant(relatedTenant1);
  }

  const relatedTenant2 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const MedicalRecord2 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (MedicalRecord2?.setTenant) {
    await MedicalRecord2.setTenant(relatedTenant2);
  }

  const relatedTenant3 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const MedicalRecord3 = await MedicalRecords.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (MedicalRecord3?.setTenant) {
    await MedicalRecord3.setTenant(relatedTenant3);
  }
}

async function associatePatientWithTenant() {
  const relatedTenant0 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Patient0 = await Patients.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Patient0?.setTenant) {
    await Patient0.setTenant(relatedTenant0);
  }

  const relatedTenant1 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Patient1 = await Patients.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Patient1?.setTenant) {
    await Patient1.setTenant(relatedTenant1);
  }

  const relatedTenant2 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Patient2 = await Patients.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Patient2?.setTenant) {
    await Patient2.setTenant(relatedTenant2);
  }

  const relatedTenant3 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Patient3 = await Patients.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Patient3?.setTenant) {
    await Patient3.setTenant(relatedTenant3);
  }
}

async function associatePatientWithTenant() {
  const relatedTenant0 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Patient0 = await Patients.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Patient0?.setTenant) {
    await Patient0.setTenant(relatedTenant0);
  }

  const relatedTenant1 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Patient1 = await Patients.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Patient1?.setTenant) {
    await Patient1.setTenant(relatedTenant1);
  }

  const relatedTenant2 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Patient2 = await Patients.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Patient2?.setTenant) {
    await Patient2.setTenant(relatedTenant2);
  }

  const relatedTenant3 = await Tenants.findOne({
    offset: Math.floor(Math.random() * (await Tenants.count())),
  });
  const Patient3 = await Patients.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Patient3?.setTenant) {
    await Patient3.setTenant(relatedTenant3);
  }
}

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

    await Invoices.bulkCreate(InvoicesData);

    await MedicalRecords.bulkCreate(MedicalRecordsData);

    await Patients.bulkCreate(PatientsData);

    await Tenants.bulkCreate(TenantsData);

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

      await associateUserWithTenant(),

      await associateAppointmentWithPatient(),

      await associateAppointmentWithHealth_professional(),

      await associateAppointmentWithTenant(),

      await associateAppointmentWithTenant(),

      await associateInvoiceWithPatient(),

      await associateInvoiceWithTenant(),

      await associateInvoiceWithTenant(),

      await associateMedicalRecordWithPatient(),

      await associateMedicalRecordWithTenant(),

      await associateMedicalRecordWithTenant(),

      await associatePatientWithTenant(),

      await associatePatientWithTenant(),
    ]);
  },

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

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

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

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

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