// src/server/features/personnel/personnel.events.ts
// Event listeners and emitters for personnel module

import { emitter, onEvent } from '../../shared/lib/events';
import { logger } from '../../shared/lib/logger';

/**
 * Event payload types for personnel events
 */
export interface EmployeeCreatedEvent {
  employeeId: string;
  employee: any;
  createdBy?: string;
}

export interface EmployeeUpdatedEvent {
  employeeId: string;
  employee: any;
  updatedBy?: string;
}

export interface EmployeeFiredEvent {
  employeeId: string;
  employee: any;
  firedBy?: string;
  firedReason: string;
  firedAt: Date;
}

export interface EmployeeRehiredEvent {
  employeeId: string;
  employee: any;
  rehiredBy?: string;
  returnReason: string;
  rehireDate: Date;
}

/**
 * Register all personnel event listeners
 * Call this once during application initialization
 */
export function registerPersonnelEventListeners(): void {
  // Listen for employee:created events
  onEvent<EmployeeCreatedEvent>('employee:created', async (data) => {
    try {
      logger.info(`[Events] employee:created received for employee ${data.employeeId}`);
      // TODO: Add notification logic for admins about new employee
      // For example: notify admins about new employee registration
    } catch (error) {
      logger.error(`[Events] Error handling employee:created:`, error);
    }
  });

  // Listen for employee:updated events
  onEvent<EmployeeUpdatedEvent>('employee:updated', async (data) => {
    try {
      logger.info(`[Events] employee:updated received for employee ${data.employeeId}`);
      // TODO: Add notification logic if needed
    } catch (error) {
      logger.error(`[Events] Error handling employee:updated:`, error);
    }
  });

  // Listen for employee:fired events
  onEvent<EmployeeFiredEvent>('employee:fired', async (data) => {
    try {
      logger.info(`[Events] employee:fired received for employee ${data.employeeId}`);
      // TODO: Add notification logic for admins about fired employee
    } catch (error) {
      logger.error(`[Events] Error handling employee:fired:`, error);
    }
  });

  // Listen for employee:rehired events
  onEvent<EmployeeRehiredEvent>('employee:rehired', async (data) => {
    try {
      logger.info(`[Events] employee:rehired received for employee ${data.employeeId}`);
      // TODO: Add notification logic for admins about rehired employee
    } catch (error) {
      logger.error(`[Events] Error handling employee:rehired:`, error);
    }
  });

  logger.info('[Events] Personnel event listeners registered successfully');
}

/**
 * Helper function to emit employee:created event
 */
export async function emitEmployeeCreatedEvent(data: EmployeeCreatedEvent): Promise<void> {
  await emitter.emit('employee:created', data);
}

/**
 * Helper function to emit employee:updated event
 */
export async function emitEmployeeUpdatedEvent(data: EmployeeUpdatedEvent): Promise<void> {
  await emitter.emit('employee:updated', data);
}

/**
 * Helper function to emit employee:fired event
 */
export async function emitEmployeeFiredEvent(data: EmployeeFiredEvent): Promise<void> {
  await emitter.emit('employee:fired', data);
}

/**
 * Helper function to emit employee:rehired event
 */
export async function emitEmployeeRehiredEvent(data: EmployeeRehiredEvent): Promise<void> {
  await emitter.emit('employee:rehired', data);
}