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

const Bookings = db.bookings;

const Reviews = db.reviews;

const ServiceCategories = db.service_categories;

const Services = db.services;

const Providerspace = db.providerspace;

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

    // type code here for "relation_one" field

    // type code here for "relation_one" field

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

    status: 'Confirmed',

    payment_status: 'Pending',

    // 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

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

    status: 'Confirmed',

    payment_status: 'Refunded',

    // 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

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

    status: 'Cancelled',

    payment_status: 'Paid',

    // 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

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

    status: 'Completed',

    payment_status: 'Paid',

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

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

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    rating: 5,

    comment: 'Excellent service, very professional.',

    // 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

    rating: 4,

    comment: 'Good job, but could be more thorough.',

    // 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

    rating: 5,

    comment: 'Quick and efficient installation.',

    // 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

    rating: 3,

    comment: 'Average service, not very punctual.',

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

const ServiceCategoriesData = [
  {
    name: 'Plumbing',

    description: 'Services related to plumbing and pipe repairs.',

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

  {
    name: 'Cleaning',

    description: 'House and office cleaning services.',

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

  {
    name: 'Electrical',

    description: 'Electrical installation and repair services.',

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

  {
    name: 'Gardening',

    description: 'Lawn mowing and garden maintenance services.',

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

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

    // type code here for "relation_one" field

    title: 'Leak Repair',

    description: 'Fixing leaks in pipes and faucets.',

    price: 50,

    availability: '{Monday: 9am-5pm, Wednesday: 9am-5pm}',

    rating: 4.5,

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

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    title: 'House Cleaning',

    description: 'Comprehensive house cleaning services.',

    price: 75,

    availability: '{Tuesday: 10am-6pm, Thursday: 10am-6pm}',

    rating: 4.7,

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

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    title: 'Light Installation',

    description: 'Installing new light fixtures.',

    price: 100,

    availability: '{Friday: 8am-4pm, Saturday: 8am-4pm}',

    rating: 4.8,

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

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    title: 'Lawn Mowing',

    description: 'Regular lawn mowing services.',

    price: 40,

    availability: '{Monday: 7am-3pm, Wednesday: 7am-3pm}',

    rating: 4.6,

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

const ProviderspaceData = [
  {
    name: 'Stephen Hawking',
  },

  {
    name: 'Ernest Rutherford',
  },

  {
    name: 'Leonard Euler',
  },

  {
    name: 'Stephen Hawking',
  },
];

// Similar logic for "relation_many"

async function associateUserWithProviderspace() {
  const relatedProviderspace0 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const User0 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (User0?.setProviderspace) {
    await User0.setProviderspace(relatedProviderspace0);
  }

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

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

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

async function associateBookingWithCustomer() {
  const relatedCustomer0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Booking0 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Booking0?.setCustomer) {
    await Booking0.setCustomer(relatedCustomer0);
  }

  const relatedCustomer1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Booking1 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Booking1?.setCustomer) {
    await Booking1.setCustomer(relatedCustomer1);
  }

  const relatedCustomer2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Booking2 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Booking2?.setCustomer) {
    await Booking2.setCustomer(relatedCustomer2);
  }

  const relatedCustomer3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Booking3 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Booking3?.setCustomer) {
    await Booking3.setCustomer(relatedCustomer3);
  }
}

async function associateBookingWithProvider() {
  const relatedProvider0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Booking0 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Booking0?.setProvider) {
    await Booking0.setProvider(relatedProvider0);
  }

  const relatedProvider1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Booking1 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Booking1?.setProvider) {
    await Booking1.setProvider(relatedProvider1);
  }

  const relatedProvider2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Booking2 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Booking2?.setProvider) {
    await Booking2.setProvider(relatedProvider2);
  }

  const relatedProvider3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Booking3 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Booking3?.setProvider) {
    await Booking3.setProvider(relatedProvider3);
  }
}

async function associateBookingWithService() {
  const relatedService0 = await Services.findOne({
    offset: Math.floor(Math.random() * (await Services.count())),
  });
  const Booking0 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Booking0?.setService) {
    await Booking0.setService(relatedService0);
  }

  const relatedService1 = await Services.findOne({
    offset: Math.floor(Math.random() * (await Services.count())),
  });
  const Booking1 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Booking1?.setService) {
    await Booking1.setService(relatedService1);
  }

  const relatedService2 = await Services.findOne({
    offset: Math.floor(Math.random() * (await Services.count())),
  });
  const Booking2 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Booking2?.setService) {
    await Booking2.setService(relatedService2);
  }

  const relatedService3 = await Services.findOne({
    offset: Math.floor(Math.random() * (await Services.count())),
  });
  const Booking3 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Booking3?.setService) {
    await Booking3.setService(relatedService3);
  }
}

async function associateBookingWithProviderspace() {
  const relatedProviderspace0 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Booking0 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Booking0?.setProviderspace) {
    await Booking0.setProviderspace(relatedProviderspace0);
  }

  const relatedProviderspace1 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Booking1 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Booking1?.setProviderspace) {
    await Booking1.setProviderspace(relatedProviderspace1);
  }

  const relatedProviderspace2 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Booking2 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Booking2?.setProviderspace) {
    await Booking2.setProviderspace(relatedProviderspace2);
  }

  const relatedProviderspace3 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Booking3 = await Bookings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Booking3?.setProviderspace) {
    await Booking3.setProviderspace(relatedProviderspace3);
  }
}

async function associateReviewWithBooking() {
  const relatedBooking0 = await Bookings.findOne({
    offset: Math.floor(Math.random() * (await Bookings.count())),
  });
  const Review0 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Review0?.setBooking) {
    await Review0.setBooking(relatedBooking0);
  }

  const relatedBooking1 = await Bookings.findOne({
    offset: Math.floor(Math.random() * (await Bookings.count())),
  });
  const Review1 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Review1?.setBooking) {
    await Review1.setBooking(relatedBooking1);
  }

  const relatedBooking2 = await Bookings.findOne({
    offset: Math.floor(Math.random() * (await Bookings.count())),
  });
  const Review2 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Review2?.setBooking) {
    await Review2.setBooking(relatedBooking2);
  }

  const relatedBooking3 = await Bookings.findOne({
    offset: Math.floor(Math.random() * (await Bookings.count())),
  });
  const Review3 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Review3?.setBooking) {
    await Review3.setBooking(relatedBooking3);
  }
}

async function associateReviewWithCustomer() {
  const relatedCustomer0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review0 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Review0?.setCustomer) {
    await Review0.setCustomer(relatedCustomer0);
  }

  const relatedCustomer1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review1 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Review1?.setCustomer) {
    await Review1.setCustomer(relatedCustomer1);
  }

  const relatedCustomer2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review2 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Review2?.setCustomer) {
    await Review2.setCustomer(relatedCustomer2);
  }

  const relatedCustomer3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review3 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Review3?.setCustomer) {
    await Review3.setCustomer(relatedCustomer3);
  }
}

async function associateReviewWithProvider() {
  const relatedProvider0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review0 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Review0?.setProvider) {
    await Review0.setProvider(relatedProvider0);
  }

  const relatedProvider1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review1 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Review1?.setProvider) {
    await Review1.setProvider(relatedProvider1);
  }

  const relatedProvider2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review2 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Review2?.setProvider) {
    await Review2.setProvider(relatedProvider2);
  }

  const relatedProvider3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Review3 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Review3?.setProvider) {
    await Review3.setProvider(relatedProvider3);
  }
}

async function associateReviewWithProviderspace() {
  const relatedProviderspace0 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Review0 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Review0?.setProviderspace) {
    await Review0.setProviderspace(relatedProviderspace0);
  }

  const relatedProviderspace1 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Review1 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Review1?.setProviderspace) {
    await Review1.setProviderspace(relatedProviderspace1);
  }

  const relatedProviderspace2 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Review2 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Review2?.setProviderspace) {
    await Review2.setProviderspace(relatedProviderspace2);
  }

  const relatedProviderspace3 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Review3 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Review3?.setProviderspace) {
    await Review3.setProviderspace(relatedProviderspace3);
  }
}

async function associateServiceCategoryWithProviderspace() {
  const relatedProviderspace0 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const ServiceCategory0 = await ServiceCategories.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ServiceCategory0?.setProviderspace) {
    await ServiceCategory0.setProviderspace(relatedProviderspace0);
  }

  const relatedProviderspace1 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const ServiceCategory1 = await ServiceCategories.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ServiceCategory1?.setProviderspace) {
    await ServiceCategory1.setProviderspace(relatedProviderspace1);
  }

  const relatedProviderspace2 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const ServiceCategory2 = await ServiceCategories.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ServiceCategory2?.setProviderspace) {
    await ServiceCategory2.setProviderspace(relatedProviderspace2);
  }

  const relatedProviderspace3 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const ServiceCategory3 = await ServiceCategories.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (ServiceCategory3?.setProviderspace) {
    await ServiceCategory3.setProviderspace(relatedProviderspace3);
  }
}

async function associateServiceWithProvider() {
  const relatedProvider0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Service0 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Service0?.setProvider) {
    await Service0.setProvider(relatedProvider0);
  }

  const relatedProvider1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Service1 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Service1?.setProvider) {
    await Service1.setProvider(relatedProvider1);
  }

  const relatedProvider2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Service2 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Service2?.setProvider) {
    await Service2.setProvider(relatedProvider2);
  }

  const relatedProvider3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Service3 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Service3?.setProvider) {
    await Service3.setProvider(relatedProvider3);
  }
}

async function associateServiceWithCategory() {
  const relatedCategory0 = await ServiceCategories.findOne({
    offset: Math.floor(Math.random() * (await ServiceCategories.count())),
  });
  const Service0 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Service0?.setCategory) {
    await Service0.setCategory(relatedCategory0);
  }

  const relatedCategory1 = await ServiceCategories.findOne({
    offset: Math.floor(Math.random() * (await ServiceCategories.count())),
  });
  const Service1 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Service1?.setCategory) {
    await Service1.setCategory(relatedCategory1);
  }

  const relatedCategory2 = await ServiceCategories.findOne({
    offset: Math.floor(Math.random() * (await ServiceCategories.count())),
  });
  const Service2 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Service2?.setCategory) {
    await Service2.setCategory(relatedCategory2);
  }

  const relatedCategory3 = await ServiceCategories.findOne({
    offset: Math.floor(Math.random() * (await ServiceCategories.count())),
  });
  const Service3 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Service3?.setCategory) {
    await Service3.setCategory(relatedCategory3);
  }
}

async function associateServiceWithProviderspace() {
  const relatedProviderspace0 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Service0 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Service0?.setProviderspace) {
    await Service0.setProviderspace(relatedProviderspace0);
  }

  const relatedProviderspace1 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Service1 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Service1?.setProviderspace) {
    await Service1.setProviderspace(relatedProviderspace1);
  }

  const relatedProviderspace2 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Service2 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Service2?.setProviderspace) {
    await Service2.setProviderspace(relatedProviderspace2);
  }

  const relatedProviderspace3 = await Providerspace.findOne({
    offset: Math.floor(Math.random() * (await Providerspace.count())),
  });
  const Service3 = await Services.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Service3?.setProviderspace) {
    await Service3.setProviderspace(relatedProviderspace3);
  }
}

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

    await Reviews.bulkCreate(ReviewsData);

    await ServiceCategories.bulkCreate(ServiceCategoriesData);

    await Services.bulkCreate(ServicesData);

    await Providerspace.bulkCreate(ProviderspaceData);

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

      await associateUserWithProviderspace(),

      await associateBookingWithCustomer(),

      await associateBookingWithProvider(),

      await associateBookingWithService(),

      await associateBookingWithProviderspace(),

      await associateReviewWithBooking(),

      await associateReviewWithCustomer(),

      await associateReviewWithProvider(),

      await associateReviewWithProviderspace(),

      await associateServiceCategoryWithProviderspace(),

      await associateServiceWithProvider(),

      await associateServiceWithCategory(),

      await associateServiceWithProviderspace(),
    ]);
  },

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

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

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

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

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