const redis = require("redis");
require("dotenv").config();

// Import fallback store for seeding
const fallbackStore = require("./src/utils/fallback-store");

// Configuration for seeding
const config = {
  numEvents: parseInt(process.argv[2]) || 5, // Number of events to create
  ticketsPerEvent: parseInt(process.argv[3]) || 10000, // Tickets per event
  redisUrl: process.env.REDIS_URL || "redis://localhost:6379",
};

const client = redis.createClient({ url: config.redisUrl });

async function seedTickets() {
  try {
    await client.connect();
    console.log(
      `Seeding ${config.numEvents} events with ${config.ticketsPerEvent} tickets each...`
    );

    // Clear existing event data
    const existingKeys = await client.keys("event:*");
    if (existingKeys.length > 0) {
      await client.del(existingKeys);
      console.log(`Cleared ${existingKeys.length} existing event keys.`);
    }

    // Seed multiple events
    for (let eventId = 1; eventId <= config.numEvents; eventId++) {
      const eventKey = `event:${eventId}:tickets`;
      const metaKey = `event:${eventId}:meta`;

      // Generate tickets for this event
      const tickets = [];
      for (let i = 1; i <= config.ticketsPerEvent; i++) {
        tickets.push(`ticket-${eventId}-${i}`);
      }

      // Store tickets in Redis list
      await client.rPush(eventKey, tickets);

      // Store event metadata
      const metadata = {
        eventId: eventId,
        totalTickets: config.ticketsPerEvent,
        soldTickets: 0,
        createdAt: new Date().toISOString(),
        name: `Event ${eventId}`,
        description: `Sample event ${eventId} for load testing`,
      };

      await client.hSet(metaKey, metadata);

      console.log(
        `✓ Event ${eventId}: ${config.ticketsPerEvent} tickets seeded`
      );
    }

    // Store global stats
    await client.hSet("global:stats", {
      totalEvents: config.numEvents,
      totalTickets: config.numEvents * config.ticketsPerEvent,
      totalSold: 0,
      lastSeeded: new Date().toISOString(),
    });

    // Also seed the fallback store
    await seedFallbackStore();

    console.log(
      `\n🎉 Successfully seeded ${config.numEvents} events with ${
        config.numEvents * config.ticketsPerEvent
      } total tickets!`
    );
    console.log(`📦 Fallback store also seeded for resilience`);
    process.exit(0);
  } catch (err) {
    console.error("Error during seed:", err);
    process.exit(1);
  }
}

async function seedFallbackStore() {
  try {
    console.log("\n🌐 Seeding fallback store...");

    // Activate fallback store temporarily for seeding
    fallbackStore.activate("Seeding fallback store during initialization");

    // Seed the same events in fallback store
    for (let eventId = 1; eventId <= config.numEvents; eventId++) {
      const tickets = [];
      for (let i = 1; i <= config.ticketsPerEvent; i++) {
        tickets.push(`ticket-${eventId}-${i}`);
      }

      const metadata = {
        eventId: eventId,
        totalTickets: config.ticketsPerEvent,
        soldTickets: 0,
        createdAt: new Date().toISOString(),
        name: `Event ${eventId}`,
        description: `Sample event ${eventId} for load testing`,
      };

      fallbackStore.seedEvent(eventId, tickets, metadata);
    }

    // Update global stats in fallback store
    fallbackStore.globalStats.lastSeeded = new Date().toISOString();

    console.log(`✓ Fallback store seeded with ${config.numEvents} events`);

    // Deactivate fallback store after seeding (will be activated when needed)
    fallbackStore.deactivate();
  } catch (error) {
    console.error("Error seeding fallback store:", error);
    // Don't fail the entire seeding process if fallback seeding fails
  }
}

seedTickets();