// apps/pedidos-api/src/services/PedidosService.ts

import { Connection, Message } from 'activemq-client';
import { EventEmitter } from 'events';
import { Logger } from '../utils/logger';
import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm';

interface PedidoMessage {
  id: string;
  clienteId: string;
  items: Array<{
    productoId: string;
    cantidad: number;
    precio: number;
  }>;
  total: number;
  estado: 'PENDIENTE' | 'PROCESANDO' | 'COMPLETADO' | 'FALLIDO';
  fechaCreacion: string;
}

export class PedidosService extends EventEmitter {
  private connection: Connection | null = null;
  private logger: Logger;
  private ssm: SSMClient;
  private readonly environment: string;

  constructor() {
    super();
    this.logger = new Logger('PedidosService');
    this.ssm = new SSMClient({});
    this.environment = process.env.ENVIRONMENT || 'dev';
  }

  async initialize(): Promise<void> {
    try {
      // Obtener credenciales de MQ desde Parameter Store
      const parameterResponse = await this.ssm.send(
        new GetParameterCommand({
          Name: `/${this.environment}/messaging/credentials`,
          WithDecryption: true
        })
      );

      const credentials = JSON.parse(parameterResponse.Parameter!.Value!);

      // Conectar a ActiveMQ
      this.connection = await this.conectarMQ(credentials);
      
      // Configurar listeners
      await this.configurarColas();
      
      this.logger.info('Servicio de pedidos inicializado correctamente');
    } catch (error) {
      this.logger.error('Error inicializando servicio de pedidos:', error);
      throw error;
    }
  }

  private async conectarMQ(credentials: any): Promise<Connection> {
    return new Promise((resolve, reject) => {
      const connection = new Connection({
        host: credentials.endpoints[0],
        port: 61617,
        username: credentials.username,
        password: credentials.password,
        ssl: true
      });

      connection.on('connect', () => {
        this.logger.info('Conectado a ActiveMQ');
        resolve(connection);
      });

      connection.on('error', (error) => {
        this.logger.error('Error en conexión MQ:', error);
        reject(error);
      });

      connection.on('disconnect', () => {
        this.logger.warn('Desconectado de ActiveMQ');
        this.reconectar();
      });
    });
  }

  private async configurarColas(): Promise<void> {
    if (!this.connection) return;

    // Cola de pedidos nuevos
    const pedidosQueue = this.connection.queue('pedidos.nuevos');
    pedidosQueue.subscribe(async (message: Message) => {
      await this.procesarPedido(message);
    });

    // Cola de actualización de estado
    const estadosQueue = this.connection.queue('pedidos.estados');
    estadosQueue.subscribe(async (message: Message) => {
      await this.actualizarEstadoPedido(message);
    });
  }

  private async procesarPedido(message: Message): Promise<void> {
    try {
      const pedido: PedidoMessage = JSON.parse(message.content.toString());
      this.logger.info(`Procesando pedido: ${pedido.id}`);

      // Validar stock
      await this.validarStock(pedido);

      // Procesar pago
      await this.procesarPago(pedido);

      // Actualizar estado
      await this.actualizarEstado(pedido.id, 'COMPLETADO');

      message.ack();
    } catch (error) {
      this.logger.error(`Error procesando pedido: ${error}`);
      message.nack();
    }
  }

  private async actualizarEstadoPedido(message: Message): Promise<void> {
    try {
      const actualizacion = JSON.parse(message.content.toString());
      await this.actualizarEstado(actualizacion.pedidoId, actualizacion.estado);
      message.ack();
    } catch (error) {
      this.logger.error(`Error actualizando estado: ${error}`);
      message.nack();
    }
  }

  private async reconectar(): Promise<void> {
    this.logger.info('Intentando reconexión...');
    try {
      const parameterResponse = await this.ssm.send(
        new GetParameterCommand({
          Name: `/${this.environment}/messaging/credentials`,
          WithDecryption: true
        })
      );

      const credentials = JSON.parse(parameterResponse.Parameter!.Value!);
      this.connection = await this.conectarMQ(credentials);
      await this.configurarColas();
    } catch (error) {
      this.logger.error('Error en reconexión:', error);
      setTimeout(() => this.reconectar(), 5000);
    }
  }

  async cerrar(): Promise<void> {
    if (this.connection) {
      await this.connection.close();
    }
  }
}

// apps/pedidos-api/src/services/MetricsService.ts

import { Counter, Gauge, Histogram } from 'prom-client';
import { CloudWatch } from 'aws-sdk';

export class MetricsService {
  private cloudwatch: CloudWatch;
  private namespace: string;

  // Prometheus metrics
  private pedidosProcesados: Counter;
  private pedidosFallidos: Counter;
  private tiempoProcesamiento: Histogram;
  private queueSize: Gauge;

  constructor(environment: string) {
    this.cloudwatch = new CloudWatch();
    this.namespace = `Pedidos/${environment}`;

    // Inicializar métricas Prometheus
    this.pedidosProcesados = new Counter({
      name: 'pedidos_procesados_total',
      help: 'Total de pedidos procesados'
    });

    this.pedidosFallidos = new Counter({
      name: 'pedidos_fallidos_total',
      help: 'Total de pedidos fallidos'
    });

    this.tiempoProcesamiento = new Histogram({
      name: 'pedidos_tiempo_procesamiento',
      help: 'Tiempo de procesamiento de pedidos',
      buckets: [1, 5, 10, 30, 60, 120]
    });

    this.queueSize = new Gauge({
      name: 'pedidos_queue_size',
      help: 'Tamaño actual de la cola de pedidos'
    });
  }

  async registrarPedidoProcesado(tiempoProcesamiento: number): Promise<void> {
    // Prometheus
    this.pedidosProcesados.inc();
    this.tiempoProcesamiento.observe(tiempoProcesamiento);

    // CloudWatch
    await this.cloudwatch.putMetricData({
      Namespace: this.namespace,
      MetricData: [
        {
          MetricName: 'PedidosProcesados',
          Value: 1,
          Unit: 'Count'
        },
        {
          MetricName: 'TiempoProcesamiento',
          Value: tiempoProcesamiento,
          Unit: 'Seconds'
        }
      ]
    }).promise();
  }

  async registrarPedidoFallido(error: string): Promise<void> {
    // Prometheus
    this.pedidosFallidos.inc();

    // CloudWatch
    await this.cloudwatch.putMetricData({
      Namespace: this.namespace,
      MetricData: [
        {
          MetricName: 'PedidosFallidos',
          Value: 1,
          Unit: 'Count',
          Dimensions: [
            {
              Name: 'TipoError',
              Value: error
            }
          ]
        }
      ]
    }).promise();
  }

  async actualizarTamañoCola(tamaño: number): Promise<void> {
    // Prometheus
    this.queueSize.set(tamaño);

    // CloudWatch
    await this.cloudwatch.putMetricData({
      Namespace: this.namespace,
      MetricData: [
        {
          MetricName: 'TamañoCola',
          Value: tamaño,
          Unit: 'Count'
        }
      ]
    }).promise();
  }

  async registrarLatenciaMQ(latencia: number): Promise<void> {
    await this.cloudwatch.putMetricData({
      Namespace: this.namespace,
      MetricData: [
        {
          MetricName: 'LatenciaMQ',
          Value: latencia,
          Unit: 'Milliseconds'
        }
      ]
    }).promise();
  }

  async registrarEstadoConexion(conectado: boolean): Promise<void> {
    await this.cloudwatch.putMetricData({
      Namespace: this.namespace,
      MetricData: [
        {
          MetricName: 'EstadoConexionMQ',
          Value: conectado ? 1 : 0,
          Unit: 'Count'
        }
      ]
    }).promise();
  }
}

// tests/integration/pedidos.test.ts

import { PedidosService } from '../../src/services/PedidosService';
import { MetricsService } from '../../src/services/MetricsService';
import { Connection } from 'activemq-client';
import { faker } from '@faker-js/faker';

describe('Sistema de Pedidos - Pruebas de Integración', () => {
  let pedidosService: PedidosService;
  let metricsService: MetricsService;
  let connection: Connection;

  const crearPedidoPrueba = () => ({
    id: faker.string.uuid(),
    clienteId: faker.string.uuid(),
    items: Array.from({ length: faker.number.int({ min: 1, max: 5 }) }, () => ({
      productoId: faker.string.uuid(),
      cantidad: faker.number.int({ min: 1, max: 10 }),
      precio: faker.number.float({ min: 10, max: 1000 })
    })),
    total: 0,
    estado: 'PENDIENTE',
    fechaCreacion: new Date().toISOString()
  });

  beforeAll(async () => {
    pedidosService = new PedidosService();
    metricsService = new MetricsService('test');
    await pedidosService.initialize();
  });

  afterAll(async () => {
    await pedidosService.cerrar();
  });

  describe('Procesamiento de Pedidos', () => {
    test('debe procesar un pedido correctamente', async () => {
      const pedido = crearPedidoPrueba();
      const resultado = await pedidosService.procesarPedido(pedido);

      expect(resultado.estado).toBe('COMPLETADO');
      expect(resultado.fechaProcesamiento).toBeDefined();
    });

    test('debe manejar múltiples pedidos concurrentes', async () => {
      const pedidos = Array.from({ length: 10 }, () => crearPedidoPrueba());
      const resultados = await Promise.all(
        pedidos.map(pedido => pedidosService.procesarPedido(pedido))
      );

      resultados.forEach(resultado => {
        expect(resultado.estado).toBe('COMPLETADO');
      });
    });

    test('debe manejar errores de procesamiento', async () => {
      const pedidoInvalido = {
        ...crearPedidoPrueba(),
        items: []
      };

      await expect(
        pedidosService.procesarPedido(pedidoInvalido)
      ).rejects.toThrow();
    });
  });

  describe('Alta Disponibilidad', () => {
    test('debe reconectar automáticamente', async () => {
      await pedidosService.simularDesconexion();
      await new Promise(resolve => setTimeout(resolve, 5000));

      const pedido = crearPedidoPrueba();
      const resultado = await pedidosService.procesarPedido(pedido);

      expect(resultado.estado).toBe('COMPLETADO');
    });

    test('debe mantener el orden de los mensajes', async () => {
      const pedidos = Array.from({ length: 5 }, () => crearPedidoPrueba());
      const timestamps: number[] = [];

      pedidos.forEach((pedido, index) => {
        pedido.id = `orden-${index + 1}`;
      });

      await Promise.all(
        pedidos.map(async pedido => {
          const resultado = await pedidosService.procesarPedido(pedido);
          timestamps.push(new Date(resultado.fechaProcesamiento).getTime());
        })
      );

      // Verificar orden cronológico
      const ordenado = [...timestamps].sort((a, b) => a - b);
      expect(timestamps).toEqual(ordenado);
    });
  });

  describe('Métricas y Monitoreo', () => {
    test('debe registrar métricas correctamente', async () => {
      const pedido = crearPedidoPrueba();
      const inicio = Date.now();
      
      await pedidosService.procesarPedido(pedido);
      
      const metricas = await metricsService.obtenerMetricas();
      
      expect(metricas.pedidosProcesados).toBeGreaterThan(0);
      expect(metricas.tiempoProcesamiento).toBeLessThan(5000);
    });

    test('debe registrar errores en métricas', async () => {
      const pedidoInvalido = {
        ...crearPedidoPrueba(),
        total: -100
      };

      try {
        await pedidosService.procesarPedido(pedidoInvalido);
      } catch (error) {
        // Esperado
      }

      const metricas = await metricsService.obtenerMetricas();
      expect(metricas.pedidosFallidos).toBeGreaterThan(0);
    });
  });
});