vip-coordinator/backend/src/services/unifiedDataService.ts

import { Pool } from 'pg';
import pool from '../config/database';

// Simplified, unified data service that replaces the three redundant services
class UnifiedDataService {
  private pool: Pool;

  constructor() {
    this.pool = pool;
  }

  // Helper to convert snake_case to camelCase
  private toCamelCase(obj: any): any {
    if (!obj) return obj;
    if (Array.isArray(obj)) return obj.map(item => this.toCamelCase(item));
    if (typeof obj !== 'object') return obj;

    return Object.keys(obj).reduce((result, key) => {
      const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
      result[camelKey] = this.toCamelCase(obj[key]);
      return result;
    }, {} as any);
  }

  // VIP Operations
  async getVips() {
    const query = `
      SELECT v.*, 
        COALESCE(
          JSON_AGG(
            JSON_BUILD_OBJECT(
              'flightNumber', f.flight_number,
              'airline', f.airline,
              'scheduledArrival', f.scheduled_arrival,
              'scheduledDeparture', f.scheduled_departure,
              'status', f.status
            ) ORDER BY f.scheduled_arrival
          ) FILTER (WHERE f.id IS NOT NULL), 
          '[]'
        ) as flights
      FROM vips v
      LEFT JOIN flights f ON v.id = f.vip_id
      GROUP BY v.id
      ORDER BY v.created_at DESC`;
    
    const result = await this.pool.query(query);
    return this.toCamelCase(result.rows);
  }

  async getVipById(id: string) {
    const query = `
      SELECT v.*, 
        COALESCE(
          JSON_AGG(
            JSON_BUILD_OBJECT(
              'flightNumber', f.flight_number,
              'airline', f.airline,
              'scheduledArrival', f.scheduled_arrival,
              'scheduledDeparture', f.scheduled_departure,
              'status', f.status
            ) ORDER BY f.scheduled_arrival
          ) FILTER (WHERE f.id IS NOT NULL), 
          '[]'
        ) as flights
      FROM vips v
      LEFT JOIN flights f ON v.id = f.vip_id
      WHERE v.id = $1
      GROUP BY v.id`;
    
    const result = await this.pool.query(query, [id]);
    return this.toCamelCase(result.rows[0]);
  }

  async createVip(vipData: any) {
    const { name, organization, department, transportMode, flights, expectedArrival, 
            needsAirportPickup, needsVenueTransport, notes } = vipData;

    const client = await this.pool.connect();
    try {
      await client.query('BEGIN');

      // Insert VIP
      const vipQuery = `
        INSERT INTO vips (name, organization, department, transport_mode, expected_arrival, 
                         needs_airport_pickup, needs_venue_transport, notes)
        VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
        RETURNING *`;
      
      const vipResult = await client.query(vipQuery, [
        name, organization, department || 'Office of Development', transportMode || 'flight',
        expectedArrival, needsAirportPickup !== false, needsVenueTransport !== false, notes || ''
      ]);

      const vip = vipResult.rows[0];

      // Insert flights if any
      if (transportMode === 'flight' && flights?.length > 0) {
        for (const flight of flights) {
          await client.query(
            `INSERT INTO flights (vip_id, flight_number, airline, scheduled_arrival, scheduled_departure)
             VALUES ($1, $2, $3, $4, $5)`,
            [vip.id, flight.flightNumber, flight.airline, flight.scheduledArrival, flight.scheduledDeparture]
          );
        }
      }

      await client.query('COMMIT');
      return this.getVipById(vip.id);
    } catch (error) {
      await client.query('ROLLBACK');
      throw error;
    } finally {
      client.release();
    }
  }

  async updateVip(id: string, vipData: any) {
    const { name, organization, department, transportMode, flights, expectedArrival,
            needsAirportPickup, needsVenueTransport, notes } = vipData;

    const client = await this.pool.connect();
    try {
      await client.query('BEGIN');

      // Update VIP
      const updateQuery = `
        UPDATE vips 
        SET name = $2, organization = $3, department = $4, transport_mode = $5,
            expected_arrival = $6, needs_airport_pickup = $7, needs_venue_transport = $8,
            notes = $9, updated_at = NOW()
        WHERE id = $1
        RETURNING *`;
      
      const result = await client.query(updateQuery, [
        id, name, organization, department, transportMode,
        expectedArrival, needsAirportPickup, needsVenueTransport, notes
      ]);

      if (result.rows.length === 0) {
        await client.query('ROLLBACK');
        return null;
      }

      // Update flights
      await client.query('DELETE FROM flights WHERE vip_id = $1', [id]);
      
      if (transportMode === 'flight' && flights?.length > 0) {
        for (const flight of flights) {
          await client.query(
            `INSERT INTO flights (vip_id, flight_number, airline, scheduled_arrival, scheduled_departure)
             VALUES ($1, $2, $3, $4, $5)`,
            [id, flight.flightNumber, flight.airline, flight.scheduledArrival, flight.scheduledDeparture]
          );
        }
      }

      await client.query('COMMIT');
      return this.getVipById(id);
    } catch (error) {
      await client.query('ROLLBACK');
      throw error;
    } finally {
      client.release();
    }
  }

  async deleteVip(id: string) {
    const result = await this.pool.query(
      'DELETE FROM vips WHERE id = $1 RETURNING *',
      [id]
    );
    return this.toCamelCase(result.rows[0]);
  }

  // Driver Operations
  async getDrivers() {
    const result = await this.pool.query(
      'SELECT * FROM drivers ORDER BY name ASC'
    );
    return this.toCamelCase(result.rows);
  }

  async getDriverById(id: string) {
    const result = await this.pool.query(
      'SELECT * FROM drivers WHERE id = $1',
      [id]
    );
    return this.toCamelCase(result.rows[0]);
  }

  async createDriver(driverData: any) {
    const { name, email, phone, vehicleInfo, status } = driverData;
    
    const result = await this.pool.query(
      `INSERT INTO drivers (name, email, phone, vehicle_info, status)
       VALUES ($1, $2, $3, $4, $5)
       RETURNING *`,
      [name, email, phone, vehicleInfo, status || 'available']
    );
    
    return this.toCamelCase(result.rows[0]);
  }

  async updateDriver(id: string, driverData: any) {
    const { name, email, phone, vehicleInfo, status } = driverData;
    
    const result = await this.pool.query(
      `UPDATE drivers 
       SET name = $2, email = $3, phone = $4, vehicle_info = $5, status = $6, updated_at = NOW()
       WHERE id = $1
       RETURNING *`,
      [id, name, email, phone, vehicleInfo, status]
    );
    
    return this.toCamelCase(result.rows[0]);
  }

  async deleteDriver(id: string) {
    const result = await this.pool.query(
      'DELETE FROM drivers WHERE id = $1 RETURNING *',
      [id]
    );
    return this.toCamelCase(result.rows[0]);
  }

  // Schedule Operations
  async getScheduleByVipId(vipId: string) {
    const result = await this.pool.query(
      `SELECT se.*, d.name as driver_name
       FROM schedule_events se
       LEFT JOIN drivers d ON se.driver_id = d.id
       WHERE se.vip_id = $1
       ORDER BY se.event_time ASC`,
      [vipId]
    );
    return this.toCamelCase(result.rows);
  }

  async createScheduleEvent(vipId: string, eventData: any) {
    const { driverId, eventTime, eventType, location, notes } = eventData;
    
    const result = await this.pool.query(
      `INSERT INTO schedule_events (vip_id, driver_id, event_time, event_type, location, notes)
       VALUES ($1, $2, $3, $4, $5, $6)
       RETURNING *`,
      [vipId, driverId, eventTime, eventType, location, notes]
    );
    
    return this.toCamelCase(result.rows[0]);
  }

  async updateScheduleEvent(id: string, eventData: any) {
    const { driverId, eventTime, eventType, location, notes, status } = eventData;
    
    const result = await this.pool.query(
      `UPDATE schedule_events
       SET driver_id = $2, event_time = $3, event_type = $4, location = $5, 
           notes = $6, status = $7, updated_at = NOW()
       WHERE id = $1
       RETURNING *`,
      [id, driverId, eventTime, eventType, location, notes, status]
    );
    
    return this.toCamelCase(result.rows[0]);
  }

  async deleteScheduleEvent(id: string) {
    const result = await this.pool.query(
      'DELETE FROM schedule_events WHERE id = $1 RETURNING *',
      [id]
    );
    return this.toCamelCase(result.rows[0]);
  }

  async getAllSchedules() {
    const result = await this.pool.query(
      `SELECT se.*, d.name as driver_name, v.name as vip_name
       FROM schedule_events se
       LEFT JOIN drivers d ON se.driver_id = d.id
       LEFT JOIN vips v ON se.vip_id = v.id
       ORDER BY se.event_time ASC`
    );
    
    // Group by VIP ID
    const schedules: Record<string, any[]> = {};
    result.rows.forEach((row: any) => {
      const event = this.toCamelCase(row);
      if (!schedules[event.vipId]) {
        schedules[event.vipId] = [];
      }
      schedules[event.vipId].push(event);
    });
    
    return schedules;
  }

  // User Operations (simplified)
  async getUserByEmail(email: string) {
    const result = await this.pool.query(
      'SELECT * FROM users WHERE email = $1',
      [email]
    );
    return this.toCamelCase(result.rows[0]);
  }

  async getUserById(id: string) {
    const result = await this.pool.query(
      'SELECT * FROM users WHERE id = $1',
      [id]
    );
    return this.toCamelCase(result.rows[0]);
  }

  async createUser(userData: any) {
    const { email, name, role, department, googleId } = userData;
    
    const result = await this.pool.query(
      `INSERT INTO users (email, name, role, department, google_id)
       VALUES ($1, $2, $3, $4, $5)
       RETURNING *`,
      [email, name, role || 'coordinator', department || 'Office of Development', googleId]
    );
    
    return this.toCamelCase(result.rows[0]);
  }

  async updateUserRole(email: string, role: string) {
    const result = await this.pool.query(
      `UPDATE users SET role = $2, updated_at = NOW()
       WHERE email = $1
       RETURNING *`,
      [email, role]
    );
    
    return this.toCamelCase(result.rows[0]);
  }

  async getUserCount(): Promise<number> {
    const result = await this.pool.query('SELECT COUNT(*) FROM users');
    return parseInt(result.rows[0].count, 10);
  }

  // Admin Settings (simplified)
  async getAdminSettings() {
    const result = await this.pool.query(
      'SELECT key, value FROM admin_settings'
    );
    
    return result.rows.reduce((settings: any, row: any) => {
      settings[row.key] = row.value;
      return settings;
    }, {});
  }

  async updateAdminSetting(key: string, value: string) {
    await this.pool.query(
      `INSERT INTO admin_settings (key, value)
       VALUES ($1, $2)
       ON CONFLICT (key) DO UPDATE SET value = $2, updated_at = NOW()`,
      [key, value]
    );
  }
}

export default new UnifiedDataService();