import {
    Body,
    Controller,
    Delete,
    Get,
    HttpException,
    HttpStatus,
    Param,
    Post,
    Put,
    Query,
    UseGuards,
} from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { ApiBearerAuth, ApiOperation, ApiParam, ApiQuery, ApiResponse, ApiTags } from '@nestjs/swagger';
import type { LoginUserInfo } from 'src/auth/dto/login.dto';
import { GetUser } from 'src/auth/get-user.decorator';
import { ActualizarPreciosProductosDto } from './dto/actualizar-precios-productos.dto';
import { CrearListaPreciosDto } from './dto/crear-lista-precios.dto';
import { ListaPreciosService } from './lista-precios.service';

@ApiTags('Lista de Precios')
@ApiBearerAuth()
@UseGuards(AuthGuard('jwt'))
@Controller('lista-precios')
export class ListaPreciosController {
  constructor(private readonly listaPreciosService: ListaPreciosService) {}

  @Post()
  @ApiOperation({ summary: 'Crear nueva lista de precios' })
  @ApiResponse({ status: 201, description: 'Lista creada exitosamente' })
  @ApiResponse({ status: 400, description: 'Datos inválidos' })
  async crearListaPrecios(@Body() crearListaDto: CrearListaPreciosDto, @GetUser() user: LoginUserInfo) {
    try {
      const nuevaLista = await this.listaPreciosService.crearListaPrecios(crearListaDto, user.empresa_id, user.id);
      return {
        success: true,
        message: 'Lista de precios creada exitosamente',
        data: nuevaLista,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al crear lista de precios',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Delete(':listaId/asignaciones/:asignacionId')
  @ApiOperation({ summary: 'Desactivar asignación de lista de precios' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiParam({ name: 'asignacionId', description: 'ID de la asignación' })
  @ApiResponse({
    status: 200,
    description: 'Asignación desactivada exitosamente',
  })
  async eliminarAsignacionLista(@Param('listaId') listaId: string, @Param('asignacionId') asignacionId: string) {
    try {
      await this.listaPreciosService.eliminarAsignacionLista(listaId, asignacionId);

      return {
        success: true,
        message: 'Asignación desactivada exitosamente',
        data: { id: asignacionId, activa: false },
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al desactivar asignación',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Get('precio-producto')
  @ApiOperation({ summary: 'Obtener precio de un producto específico' })
  @ApiQuery({ name: 'productoId', description: 'ID del producto' })
  @ApiQuery({ name: 'empresaId', description: 'ID de la empresa' })
  @ApiQuery({
    name: 'clienteId',
    description: 'ID del cliente',
    required: false,
  })
  @ApiQuery({
    name: 'zonaGeografica',
    description: 'Zona geográfica',
    required: false,
  })
  @ApiQuery({
    name: 'canalVenta',
    description: 'Canal de venta',
    required: false,
  })
  @ApiQuery({
    name: 'moneda',
    description: 'Código de moneda (PYG, USD, EUR, etc.)',
    required: false,
  })
  @ApiResponse({ status: 200, description: 'Precio obtenido exitosamente' })
  async obtenerPrecioProducto(
    @GetUser() user: LoginUserInfo,
    @Query('productoId') productoId: string,
    @Query('empresaId') empresaId: string,
    @Query('clienteId') clienteId?: string,
    @Query('zonaGeografica') zonaGeografica?: string,
    @Query('canalVenta') canalVenta?: string,
    @Query('moneda') moneda?: string,
  ) {
    try {
      const precio = await this.listaPreciosService.obtenerPrecioProducto({
        productoId,
        clienteId,
        zonaGeografica,
        canalVenta,
        moneda,
        empresaId: user.empresa_id,
      });

      return {
        success: true,
        data: precio,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al obtener precio del producto',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Get('precios-producto/batch')
  @ApiOperation({ summary: 'Obtener el precio real (resuelto por lista) de varios productos a la vez' })
  @ApiQuery({ name: 'productoIds', description: 'IDs de producto separados por coma' })
  @ApiQuery({ name: 'clienteId', description: 'ID del cliente (opcional, prioriza su lista asignada)', required: false })
  @ApiResponse({ status: 200, description: 'Precios obtenidos exitosamente' })
  async obtenerPreciosProductosBatch(
    @GetUser() user: LoginUserInfo,
    @Query('productoIds') productoIds: string,
    @Query('clienteId') clienteId?: string,
  ) {
    try {
      const ids = (productoIds || '')
        .split(',')
        .map((id) => id.trim())
        .filter(Boolean);
      const precios = await this.listaPreciosService.obtenerPreciosProductosBatch({
        productoIds: ids,
        empresaId: user.empresa_id,
        clienteId,
      });

      return {
        success: true,
        data: precios,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al obtener precios de productos',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Get('empresa')
  @ApiOperation({
    summary: 'Obtener listas de precios de la empresa del usuario',
  })
  @ApiQuery({
    name: 'activa',
    description: 'Filtrar por estado activo',
    required: false,
  })
  @ApiQuery({
    name: 'tipoAplicacion',
    description: 'Filtrar por tipo de aplicación',
    required: false,
  })
  @ApiQuery({
    name: 'moneda',
    description: 'Filtrar por moneda (PYG, USD, EUR, etc.)',
    required: false,
  })
  @ApiQuery({
    name: 'page',
    description: 'Página a consultar',
    required: false,
  })
  @ApiQuery({
    name: 'limit',
    description: 'Cantidad de registros por página',
    required: false,
  })
  async obtenerListasEmpresaUsuario(
    @GetUser() user: LoginUserInfo,
    @Query('activa') activa?: string,
    @Query('tipoAplicacion') tipoAplicacion?: string,
    @Query('moneda') moneda?: string,
    @Query('page') page?: string,
    @Query('limit') limit?: string,
  ) {
    const empresaId = user?.empresa_id;
    if (!empresaId) {
      throw new HttpException(
        {
          success: false,
          message: 'Empresa no encontrada para el usuario',
        },
        HttpStatus.BAD_REQUEST,
      );
    }

    return this.obtenerListasEmpresa(empresaId, activa, tipoAplicacion, moneda, page, limit);
  }

  @Get('empresa/:empresaId')
  @ApiOperation({ summary: 'Obtener listas de precios de una empresa' })
  @ApiParam({ name: 'empresaId', description: 'ID de la empresa' })
  @ApiQuery({
    name: 'activa',
    description: 'Filtrar por estado activo',
    required: false,
  })
  @ApiQuery({
    name: 'tipoAplicacion',
    description: 'Filtrar por tipo de aplicación',
    required: false,
  })
  @ApiQuery({
    name: 'moneda',
    description: 'Filtrar por moneda (PYG, USD, EUR, etc.)',
    required: false,
  })
  @ApiQuery({
    name: 'page',
    description: 'Página a consultar',
    required: false,
  })
  @ApiQuery({
    name: 'limit',
    description: 'Cantidad de registros por página',
    required: false,
  })
  @ApiResponse({ status: 200, description: 'Listas obtenidas exitosamente' })
  async obtenerListasEmpresa(
    @Param('empresaId') empresaId: string,
    @Query('activa') activa?: string,
    @Query('tipoAplicacion') tipoAplicacion?: string,
    @Query('moneda') moneda?: string,
    @Query('page') page?: string,
    @Query('limit') limit?: string,
  ) {
    try {
      if (!empresaId || empresaId === 'undefined') {
        throw new HttpException(
          {
            success: false,
            message: 'Empresa no proporcionada',
          },
          HttpStatus.BAD_REQUEST,
        );
      }

      const filtros = {
        activa: activa ? activa === 'true' : undefined,
        tipoAplicacion,
        moneda,
      };

      const resultado = await this.listaPreciosService.obtenerListasEmpresa(
        empresaId,
        filtros,
        Number(page) || 1,
        Number(limit) || 20,
      );

      return {
        success: true,
        ...resultado,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al obtener listas de empresa',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Get('producto/:productoId/precios')
  @ApiOperation({
    summary: 'Obtener todas las listas de precios donde aparece un producto específico',
  })
  @ApiParam({ name: 'productoId', description: 'ID del producto' })
  @ApiResponse({
    status: 200,
    description: 'Precios del producto obtenidos exitosamente',
  })
  async obtenerPreciosProducto(@GetUser() user: LoginUserInfo, @Param('productoId') productoId: string) {
    try {
      const empresaId = user?.empresa_id;
      if (!empresaId) {
        throw new HttpException(
          {
            success: false,
            message: 'Empresa no encontrada para el usuario',
          },
          HttpStatus.BAD_REQUEST,
        );
      }

      const precios = await this.listaPreciosService.obtenerPreciosProducto(productoId, empresaId);

      return {
        success: true,
        data: precios,
        total: precios.length,
      };
    } catch (error) {
      if (error instanceof HttpException) {
        throw error;
      }
      throw new HttpException(
        {
          success: false,
          message: 'Error al obtener precios del producto',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Get(':listaId')
  @ApiOperation({ summary: 'Obtener lista de precios por ID' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiResponse({ status: 200, description: 'Lista obtenida exitosamente' })
  @ApiResponse({ status: 404, description: 'Lista no encontrada' })
  async obtenerListaPorId(@Param('listaId') listaId: string) {
    try {
      const lista = await this.listaPreciosService.obtenerListaPorId(listaId);

      if (!lista) {
        throw new HttpException(
          {
            success: false,
            message: 'Lista de precios no encontrada',
          },
          HttpStatus.NOT_FOUND,
        );
      }

      return {
        success: true,
        data: lista,
      };
    } catch (error) {
      if (error instanceof HttpException) {
        throw error;
      }
      throw new HttpException(
        {
          success: false,
          message: 'Error al obtener lista por ID',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Put(':listaId/precios')
  @ApiOperation({ summary: 'Actualizar precios de productos en una lista' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiResponse({
    status: 200,
    description: 'Precios actualizados exitosamente',
  })
  async actualizarPreciosProductos(
    @Param('listaId') listaId: string,
    @Body() actualizarPreciosDto: ActualizarPreciosProductosDto,
    @GetUser() user: LoginUserInfo,
  ) {
    try {
      const resultados = await this.listaPreciosService.actualizarPreciosProductos(
        listaId,
        actualizarPreciosDto.productos,
        user.id,
        user.empresa_id,
      );

      return {
        success: true,
        message: 'Precios actualizados exitosamente',
        data: {
          productos_actualizados: resultados.length,
          detalles: resultados,
        },
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al actualizar precios',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Post(':listaId/duplicar')
  @ApiOperation({ summary: 'Duplicar una lista de precios existente' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista a duplicar' })
  @ApiResponse({ status: 201, description: 'Lista duplicada exitosamente' })
  async duplicarListaPrecios(
    @Param('listaId') listaId: string,
    @Body()
    nuevosDatos: { codigo: string; nombre: string; descripcion?: string },
    @GetUser() user: LoginUserInfo,
  ) {
    try {
      const listaDuplicada = await this.listaPreciosService.duplicarListaPrecios(listaId, nuevosDatos, user.id);

      return {
        success: true,
        message: 'Lista duplicada exitosamente',
        data: listaDuplicada,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al duplicar lista',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Put(':listaId/descuento-masivo')
  @ApiOperation({ summary: 'Aplicar descuento masivo a una lista de precios' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiResponse({ status: 200, description: 'Descuento aplicado exitosamente' })
  async aplicarDescuentoMasivo(
    @Param('listaId') listaId: string,
    @Body() body: { descuentoPorcentaje: number; filtros?: any },
  ) {
    try {
      const resultado = await this.listaPreciosService.aplicarDescuentoMasivo(
        listaId,
        body.descuentoPorcentaje,
        body.filtros || {},
      );

      return {
        success: true,
        message: 'Descuento aplicado exitosamente',
        data: resultado,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al aplicar descuento masivo',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Delete(':listaId')
  @ApiOperation({ summary: 'Desactivar una lista de precios' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiResponse({ status: 200, description: 'Lista desactivada exitosamente' })
  async desactivarListaPrecios(@Param('listaId') listaId: string) {
    try {
      // Placeholder para desactivación
      return {
        success: true,
        message: 'Lista desactivada exitosamente',
        data: { id: listaId, activa: false },
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al desactivar lista',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  // ===== ENDPOINTS PARA GESTIÓN DE ASIGNACIONES =====

  @Post(':listaId/asignaciones')
  @ApiOperation({
    summary: 'Asignar lista de precios a entidades (clientes, zonas, canales)',
  })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiResponse({
    status: 201,
    description: 'Asignaciones creadas exitosamente',
  })
  async asignarListaPrecios(
    @Param('listaId') listaId: string,
    @Body()
    asignaciones: {
      tipoEntidad: string;
      entidadId: string;
      prioridad?: number;
    }[],
  ) {
    try {
      const resultados = await this.listaPreciosService.asignarListaPrecios(listaId, asignaciones);

      return {
        success: true,
        message: 'Asignaciones creadas exitosamente',
        data: {
          asignaciones_creadas: resultados.length,
          detalles: resultados,
        },
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al crear asignaciones',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Get(':listaId/asignaciones')
  @ApiOperation({ summary: 'Obtener asignaciones de una lista de precios' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiResponse({
    status: 200,
    description: 'Asignaciones obtenidas exitosamente',
  })
  async obtenerAsignacionesLista(@Param('listaId') listaId: string) {
    try {
      const asignaciones = await this.listaPreciosService.obtenerAsignacionesLista(listaId);

      return {
        success: true,
        data: asignaciones,
        total: asignaciones.length,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al obtener asignaciones',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  // ===== ENDPOINTS PARA GESTIÓN DE PRODUCTOS =====

  @Get(':listaId/productos')
  @ApiOperation({ summary: 'Obtener productos de una lista de precios' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiQuery({ name: 'page', description: 'Página', required: false })
  @ApiQuery({
    name: 'limit',
    description: 'Límite por página',
    required: false,
  })
  @ApiResponse({ status: 200, description: 'Productos obtenidos exitosamente' })
  async obtenerProductosLista(
    @Param('listaId') listaId: string,
    @Query('page') page?: string,
    @Query('limit') limit?: string,
  ) {
    try {
      const resultado = await this.listaPreciosService.obtenerProductosLista(
        listaId,
        parseInt(page) || 1,
        parseInt(limit) || 50,
      );

      return {
        success: true,
        ...resultado,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al obtener productos de la lista',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Put(':listaId/productos/:productoListaId')
  @ApiOperation({
    summary: 'Actualizar precio de un producto en una lista de precios',
  })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiParam({
    name: 'productoListaId',
    description: 'ID del registro producto-lista',
  })
  @ApiResponse({
    status: 200,
    description: 'Producto actualizado exitosamente',
  })
  async actualizarProductoLista(
    @Param('listaId') listaId: string,
    @Param('productoListaId') productoListaId: string,
    @Body()
    datos: {
      precio_base?: number;
      descuento_porcentaje?: number;
      recargo_porcentaje?: number;
      precio_minimo?: number;
      precio_maximo?: number;
      descuento_maximo_pct?: number;
      permite_cuotas?: boolean;
      cuotas_maximas?: number;
    },
  ) {
    try {
      const actualizado = await this.listaPreciosService.actualizarProductoLista(listaId, productoListaId, datos);

      return {
        success: true,
        message: 'Producto actualizado exitosamente',
        data: actualizado,
      };
    } catch (error) {
      if (error instanceof HttpException) {
        throw error;
      }
      throw new HttpException(
        {
          success: false,
          message: 'Error al actualizar producto en la lista',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Delete(':listaId/productos/:productoListaId')
  @ApiOperation({ summary: 'Eliminar producto de una lista de precios' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiParam({
    name: 'productoListaId',
    description: 'ID del registro producto-lista',
  })
  @ApiResponse({
    status: 200,
    description: 'Producto eliminado de la lista exitosamente',
  })
  async eliminarProductoLista(
    @Param('listaId') listaId: string,
    @Param('productoListaId') productoListaId: string,
    @GetUser() user: LoginUserInfo,
  ) {
    try {
      await this.listaPreciosService.eliminarProductoLista(listaId, productoListaId, user.id, user.empresa_id);

      return {
        success: true,
        message: 'Producto eliminado de la lista exitosamente',
        data: { id: productoListaId },
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al eliminar producto de la lista',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  // ===== ENDPOINTS PARA OPERACIONES ADICIONALES =====

  @Put(':listaId')
  @ApiOperation({ summary: 'Actualizar una lista de precios' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiResponse({ status: 200, description: 'Lista actualizada exitosamente' })
  async actualizarListaPrecios(
    @Param('listaId') listaId: string,
    @Body() datosActualizacion: Partial<CrearListaPreciosDto>,
    @GetUser() user: LoginUserInfo,
  ) {
    try {
      const listaActualizada = await this.listaPreciosService.actualizarListaPrecios(
        listaId,
        datosActualizacion,
        user.id,
        user.empresa_id,
      );

      return {
        success: true,
        message: 'Lista actualizada exitosamente',
        data: listaActualizada,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al actualizar lista',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Put(':listaId/estado')
  @ApiOperation({ summary: 'Cambiar estado de una lista de precios' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiResponse({ status: 200, description: 'Estado cambiado exitosamente' })
  async cambiarEstadoLista(
    @Param('listaId') listaId: string,
    @Body() body: { activa: boolean },
    @GetUser() user: LoginUserInfo,
  ) {
    try {
      const listaActualizada = await this.listaPreciosService.cambiarEstadoLista(
        listaId,
        body.activa,
        user.id,
        user.empresa_id,
      );

      return {
        success: true,
        message: `Lista ${body.activa ? 'activada' : 'desactivada'} exitosamente`,
        data: listaActualizada,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al cambiar estado de la lista',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Put(':listaId/moneda')
  @ApiOperation({ summary: 'Cambiar moneda de una lista de precios' })
  @ApiParam({ name: 'listaId', description: 'ID de la lista de precios' })
  @ApiResponse({ status: 200, description: 'Moneda cambiada exitosamente' })
  async cambiarMonedaLista(@Param('listaId') listaId: string, @Body() body: { moneda: string }) {
    try {
      const listaActualizada = await this.listaPreciosService.cambiarMonedaLista(listaId, body.moneda);

      return {
        success: true,
        message: 'Moneda cambiada exitosamente',
        data: listaActualizada,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al cambiar moneda de la lista',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Get('empresa/monedas')
  @ApiOperation({
    summary: 'Obtener monedas disponibles en listas de la empresa del usuario',
  })
  @ApiResponse({ status: 200, description: 'Monedas obtenidas exitosamente' })
  async obtenerMonedasDisponiblesUsuario(@GetUser() user: LoginUserInfo) {
    const empresaId = user?.empresa_id;
    if (!empresaId) {
      throw new HttpException(
        {
          success: false,
          message: 'Empresa no encontrada para el usuario',
        },
        HttpStatus.BAD_REQUEST,
      );
    }

    return this.obtenerMonedasDisponibles(empresaId);
  }

  @Get('empresa/:empresaId/monedas')
  @ApiOperation({
    summary: 'Obtener monedas disponibles en listas de una empresa',
  })
  @ApiParam({ name: 'empresaId', description: 'ID de la empresa' })
  @ApiResponse({ status: 200, description: 'Monedas obtenidas exitosamente' })
  async obtenerMonedasDisponibles(@Param('empresaId') empresaId: string) {
    try {
      if (!empresaId || empresaId === 'undefined') {
        throw new HttpException(
          {
            success: false,
            message: 'Empresa no proporcionada',
          },
          HttpStatus.BAD_REQUEST,
        );
      }

      const monedas = await this.listaPreciosService.obtenerMonedasDisponibles(empresaId);

      return {
        success: true,
        data: monedas,
        total: monedas.length,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al obtener monedas disponibles',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  @Get('empresa/moneda/:moneda')
  @ApiOperation({ summary: 'Obtener listas de precios por moneda del usuario' })
  @ApiParam({
    name: 'moneda',
    description: 'Código de moneda (PYG, USD, EUR, etc.)',
  })
  @ApiResponse({ status: 200, description: 'Listas obtenidas exitosamente' })
  async obtenerListasPorMonedaUsuario(@GetUser() user: LoginUserInfo, @Param('moneda') moneda: string) {
    const empresaId = user?.empresa_id;
    if (!empresaId) {
      throw new HttpException(
        {
          success: false,
          message: 'Empresa no encontrada para el usuario',
        },
        HttpStatus.BAD_REQUEST,
      );
    }

    return this.obtenerListasPorMoneda(empresaId, moneda);
  }

  @Get('empresa/:empresaId/moneda/:moneda')
  @ApiOperation({ summary: 'Obtener listas de precios por moneda específica' })
  @ApiParam({ name: 'empresaId', description: 'ID de la empresa' })
  @ApiParam({
    name: 'moneda',
    description: 'Código de moneda (PYG, USD, EUR, etc.)',
  })
  @ApiResponse({ status: 200, description: 'Listas obtenidas exitosamente' })
  async obtenerListasPorMoneda(@Param('empresaId') empresaId: string, @Param('moneda') moneda: string) {
    try {
      if (!empresaId || empresaId === 'undefined') {
        throw new HttpException(
          {
            success: false,
            message: 'Empresa no proporcionada',
          },
          HttpStatus.BAD_REQUEST,
        );
      }

      const listas = await this.listaPreciosService.obtenerListasPorMoneda(empresaId, moneda);

      return {
        success: true,
        data: listas,
        total: listas.length,
      };
    } catch (error) {
      throw new HttpException(
        {
          success: false,
          message: 'Error al obtener listas por moneda',
          error: error.message,
        },
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }
}