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

const Attributes = db.attributes;

const Baskets = db.baskets;

const Codes = db.codes;

const DiscountCodes = db.discount_codes;

const KycSubmissions = db.kyc_submissions;

const OrderItems = db.order_items;

const Orders = db.orders;

const Products = db.products;

const TicketMessages = db.ticket_messages;

const Tickets = db.tickets;

const Variants = db.variants;

const WalletTransactions = db.wallet_transactions;

const AttributesData = [
  {
    name: 'Region',
  },

  {
    name: 'Value',
  },

  {
    name: 'Color',
  },

  {
    name: 'Size',
  },
];

const BasketsData = [
  {
    usd_amount: 500,

    irr_cost: 4800000,
  },

  {
    usd_amount: 1000,

    irr_cost: 9600000,
  },

  {
    usd_amount: 750,

    irr_cost: 7200000,
  },

  {
    usd_amount: 300,

    irr_cost: 2880000,
  },
];

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

    code: 'STEAM-1234-5678-9012',

    usd_value: 10,

    // type code here for "relation_one" field

    used_at: new Date(Date.now()),
  },

  {
    // type code here for "relation_one" field

    code: 'STEAM-2345-6789-0123',

    usd_value: 50,

    // type code here for "relation_one" field

    used_at: new Date('2023-10-06T15:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    code: 'PUBG-3456-7890-1234',

    usd_value: 5,

    // type code here for "relation_one" field

    used_at: new Date(Date.now()),
  },

  {
    // type code here for "relation_one" field

    code: 'PUBG-4567-8901-2345',

    usd_value: 15,

    // type code here for "relation_one" field

    used_at: new Date('2023-10-07T16:00:00Z'),
  },
];

const DiscountCodesData = [
  {
    code: 'WELCOME10',

    type: 'percentage',

    value: 10,

    max_uses: 100,

    expires_at: new Date('2023-12-31T23:59:59Z'),
  },

  {
    code: 'FALLSALE',

    type: 'fixed',

    value: 50000,

    max_uses: 50,

    expires_at: new Date('2023-11-30T23:59:59Z'),
  },

  {
    code: 'NEWUSER',

    type: 'fixed',

    value: 15,

    max_uses: 200,

    expires_at: new Date('2024-01-31T23:59:59Z'),
  },

  {
    code: 'BLACKFRIDAY',

    type: 'percentage',

    value: 100000,

    max_uses: 30,

    expires_at: new Date('2023-11-25T23:59:59Z'),
  },
];

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

    national_id: '1234567890',

    // type code here for "files" field

    // type code here for "files" field

    status: 'Pending',

    feedback: 'Verified successfully.',
  },

  {
    // type code here for "relation_one" field

    national_id: '0987654321',

    // type code here for "files" field

    // type code here for "files" field

    status: 'Approved',

    feedback: 'Awaiting verification.',
  },

  {
    // type code here for "relation_one" field

    national_id: '1122334455',

    // type code here for "files" field

    // type code here for "files" field

    status: 'Pending',

    feedback: 'Image not clear.',
  },

  {
    // type code here for "relation_one" field

    national_id: '2233445566',

    // type code here for "files" field

    // type code here for "files" field

    status: 'Pending',

    feedback: 'Verified successfully.',
  },
];

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

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    quantity: 1,

    price_irr: 1500000,

    activation_by_zipodo: true,
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    quantity: 2,

    price_irr: 500000,

    activation_by_zipodo: true,
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    quantity: 1,

    price_irr: 250000,

    activation_by_zipodo: true,
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    quantity: 3,

    price_irr: 2000000,

    activation_by_zipodo: true,
  },
];

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

    total_irr: 1500000,

    status: 'Pending',

    paid_at: new Date('2023-10-08T17:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    total_irr: 500000,

    status: 'Pending',

    paid_at: new Date(Date.now()),
  },

  {
    // type code here for "relation_one" field

    total_irr: 250000,

    status: 'Paid',

    paid_at: new Date(Date.now()),
  },

  {
    // type code here for "relation_one" field

    total_irr: 2000000,

    status: 'Paid',

    paid_at: new Date('2023-10-09T18:00:00Z'),
  },
];

const ProductsData = [
  {
    type: 'single',

    title: 'Apple Gift Card',

    description: 'Apple gift card for App Store purchases.',

    // type code here for "images" field

    price_type: 'dynamic',

    price_irr: 70.55,
  },

  {
    type: 'variable',

    title: 'Steam Gift Card',

    description: 'Steam gift card for game purchases.',

    // type code here for "images" field

    price_type: 'dynamic',

    price_irr: 500000,
  },

  {
    type: 'variable',

    title: 'PlayStation Gift Card',

    description: 'PlayStation gift card for PSN purchases.',

    // type code here for "images" field

    price_type: 'manual',

    price_irr: 31.28,
  },

  {
    type: 'variable',

    title: 'PUBG UC',

    description: 'PUBG UC for in-game purchases.',

    // type code here for "images" field

    price_type: 'manual',

    price_irr: 300000,
  },
];

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

    // type code here for "relation_one" field

    message: "I haven't received my order yet.",
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    message: 'Payment was deducted but order not confirmed.',
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    message: 'My KYC is still pending.',
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    message: 'Is the product available in Turkey?',
  },
];

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

    subject: 'Order not received',

    status: 'Closed',
  },

  {
    // type code here for "relation_one" field

    subject: 'Payment issue',

    status: 'Open',
  },

  {
    // type code here for "relation_one" field

    subject: 'KYC verification',

    status: 'Open',
  },

  {
    // type code here for "relation_one" field

    subject: 'Product inquiry',

    status: 'Open',
  },
];

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

    attribute_values: '{Region:USA,Value:10 USD}',

    price_usd: 10,

    price_irr: 17.45,
  },

  {
    // type code here for "relation_one" field

    attribute_values: '{Region:Turkey,Value:50 USD}',

    price_usd: 50,

    price_irr: 22.62,
  },

  {
    // type code here for "relation_one" field

    attribute_values: '{Region:Global,Value:600 UC}',

    price_usd: 5,

    price_irr: 150000,
  },

  {
    // type code here for "relation_one" field

    attribute_values: '{Region:Global,Value:1800 UC}',

    price_usd: 15,

    price_irr: 450000,
  },
];

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

    amount: 500000,

    type: 'refunded',
  },

  {
    // type code here for "relation_one" field

    amount: 250000,

    type: 'payment',
  },

  {
    // type code here for "relation_one" field

    amount: 100000,

    type: 'refunded',
  },

  {
    // type code here for "relation_one" field

    amount: 750000,

    type: 'refunded',
  },
];

// Similar logic for "relation_many"

async function associateCodeWithVariant() {
  const relatedVariant0 = await Variants.findOne({
    offset: Math.floor(Math.random() * (await Variants.count())),
  });
  const Code0 = await Codes.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Code0?.setVariant) {
    await Code0.setVariant(relatedVariant0);
  }

  const relatedVariant1 = await Variants.findOne({
    offset: Math.floor(Math.random() * (await Variants.count())),
  });
  const Code1 = await Codes.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Code1?.setVariant) {
    await Code1.setVariant(relatedVariant1);
  }

  const relatedVariant2 = await Variants.findOne({
    offset: Math.floor(Math.random() * (await Variants.count())),
  });
  const Code2 = await Codes.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Code2?.setVariant) {
    await Code2.setVariant(relatedVariant2);
  }

  const relatedVariant3 = await Variants.findOne({
    offset: Math.floor(Math.random() * (await Variants.count())),
  });
  const Code3 = await Codes.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Code3?.setVariant) {
    await Code3.setVariant(relatedVariant3);
  }
}

async function associateCodeWithBasket() {
  const relatedBasket0 = await Baskets.findOne({
    offset: Math.floor(Math.random() * (await Baskets.count())),
  });
  const Code0 = await Codes.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Code0?.setBasket) {
    await Code0.setBasket(relatedBasket0);
  }

  const relatedBasket1 = await Baskets.findOne({
    offset: Math.floor(Math.random() * (await Baskets.count())),
  });
  const Code1 = await Codes.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Code1?.setBasket) {
    await Code1.setBasket(relatedBasket1);
  }

  const relatedBasket2 = await Baskets.findOne({
    offset: Math.floor(Math.random() * (await Baskets.count())),
  });
  const Code2 = await Codes.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Code2?.setBasket) {
    await Code2.setBasket(relatedBasket2);
  }

  const relatedBasket3 = await Baskets.findOne({
    offset: Math.floor(Math.random() * (await Baskets.count())),
  });
  const Code3 = await Codes.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Code3?.setBasket) {
    await Code3.setBasket(relatedBasket3);
  }
}

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

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

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

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

async function associateOrderItemWithOrder() {
  const relatedOrder0 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const OrderItem0 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (OrderItem0?.setOrder) {
    await OrderItem0.setOrder(relatedOrder0);
  }

  const relatedOrder1 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const OrderItem1 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (OrderItem1?.setOrder) {
    await OrderItem1.setOrder(relatedOrder1);
  }

  const relatedOrder2 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const OrderItem2 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (OrderItem2?.setOrder) {
    await OrderItem2.setOrder(relatedOrder2);
  }

  const relatedOrder3 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const OrderItem3 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (OrderItem3?.setOrder) {
    await OrderItem3.setOrder(relatedOrder3);
  }
}

async function associateOrderItemWithProduct() {
  const relatedProduct0 = await Products.findOne({
    offset: Math.floor(Math.random() * (await Products.count())),
  });
  const OrderItem0 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (OrderItem0?.setProduct) {
    await OrderItem0.setProduct(relatedProduct0);
  }

  const relatedProduct1 = await Products.findOne({
    offset: Math.floor(Math.random() * (await Products.count())),
  });
  const OrderItem1 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (OrderItem1?.setProduct) {
    await OrderItem1.setProduct(relatedProduct1);
  }

  const relatedProduct2 = await Products.findOne({
    offset: Math.floor(Math.random() * (await Products.count())),
  });
  const OrderItem2 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (OrderItem2?.setProduct) {
    await OrderItem2.setProduct(relatedProduct2);
  }

  const relatedProduct3 = await Products.findOne({
    offset: Math.floor(Math.random() * (await Products.count())),
  });
  const OrderItem3 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (OrderItem3?.setProduct) {
    await OrderItem3.setProduct(relatedProduct3);
  }
}

async function associateOrderItemWithVariant() {
  const relatedVariant0 = await Variants.findOne({
    offset: Math.floor(Math.random() * (await Variants.count())),
  });
  const OrderItem0 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (OrderItem0?.setVariant) {
    await OrderItem0.setVariant(relatedVariant0);
  }

  const relatedVariant1 = await Variants.findOne({
    offset: Math.floor(Math.random() * (await Variants.count())),
  });
  const OrderItem1 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (OrderItem1?.setVariant) {
    await OrderItem1.setVariant(relatedVariant1);
  }

  const relatedVariant2 = await Variants.findOne({
    offset: Math.floor(Math.random() * (await Variants.count())),
  });
  const OrderItem2 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (OrderItem2?.setVariant) {
    await OrderItem2.setVariant(relatedVariant2);
  }

  const relatedVariant3 = await Variants.findOne({
    offset: Math.floor(Math.random() * (await Variants.count())),
  });
  const OrderItem3 = await OrderItems.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (OrderItem3?.setVariant) {
    await OrderItem3.setVariant(relatedVariant3);
  }
}

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

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

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

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

async function associateTicketMessageWithTicket() {
  const relatedTicket0 = await Tickets.findOne({
    offset: Math.floor(Math.random() * (await Tickets.count())),
  });
  const TicketMessage0 = await TicketMessages.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (TicketMessage0?.setTicket) {
    await TicketMessage0.setTicket(relatedTicket0);
  }

  const relatedTicket1 = await Tickets.findOne({
    offset: Math.floor(Math.random() * (await Tickets.count())),
  });
  const TicketMessage1 = await TicketMessages.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (TicketMessage1?.setTicket) {
    await TicketMessage1.setTicket(relatedTicket1);
  }

  const relatedTicket2 = await Tickets.findOne({
    offset: Math.floor(Math.random() * (await Tickets.count())),
  });
  const TicketMessage2 = await TicketMessages.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (TicketMessage2?.setTicket) {
    await TicketMessage2.setTicket(relatedTicket2);
  }

  const relatedTicket3 = await Tickets.findOne({
    offset: Math.floor(Math.random() * (await Tickets.count())),
  });
  const TicketMessage3 = await TicketMessages.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (TicketMessage3?.setTicket) {
    await TicketMessage3.setTicket(relatedTicket3);
  }
}

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

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

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

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

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

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

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

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

async function associateVariantWithProduct() {
  const relatedProduct0 = await Products.findOne({
    offset: Math.floor(Math.random() * (await Products.count())),
  });
  const Variant0 = await Variants.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Variant0?.setProduct) {
    await Variant0.setProduct(relatedProduct0);
  }

  const relatedProduct1 = await Products.findOne({
    offset: Math.floor(Math.random() * (await Products.count())),
  });
  const Variant1 = await Variants.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Variant1?.setProduct) {
    await Variant1.setProduct(relatedProduct1);
  }

  const relatedProduct2 = await Products.findOne({
    offset: Math.floor(Math.random() * (await Products.count())),
  });
  const Variant2 = await Variants.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Variant2?.setProduct) {
    await Variant2.setProduct(relatedProduct2);
  }

  const relatedProduct3 = await Products.findOne({
    offset: Math.floor(Math.random() * (await Products.count())),
  });
  const Variant3 = await Variants.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Variant3?.setProduct) {
    await Variant3.setProduct(relatedProduct3);
  }
}

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

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

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

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

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

    await Baskets.bulkCreate(BasketsData);

    await Codes.bulkCreate(CodesData);

    await DiscountCodes.bulkCreate(DiscountCodesData);

    await KycSubmissions.bulkCreate(KycSubmissionsData);

    await OrderItems.bulkCreate(OrderItemsData);

    await Orders.bulkCreate(OrdersData);

    await Products.bulkCreate(ProductsData);

    await TicketMessages.bulkCreate(TicketMessagesData);

    await Tickets.bulkCreate(TicketsData);

    await Variants.bulkCreate(VariantsData);

    await WalletTransactions.bulkCreate(WalletTransactionsData);

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

      await associateCodeWithVariant(),

      await associateCodeWithBasket(),

      await associateKycSubmissionWithUser(),

      await associateOrderItemWithOrder(),

      await associateOrderItemWithProduct(),

      await associateOrderItemWithVariant(),

      await associateOrderWithUser(),

      await associateTicketMessageWithTicket(),

      await associateTicketMessageWithUser(),

      await associateTicketWithUser(),

      await associateVariantWithProduct(),

      await associateWalletTransactionWithUser(),
    ]);
  },

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

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

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

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

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

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

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

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

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

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

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

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