import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { MensajeWhatsApp } from './entities/mensaje.entity.js';
import { MensajeWhatsAppDto } from './dto/mensaje.dto.js';
import { UpdateEstadoDto } from './dto/update-estado.dto.js';
import { defaultServiceResult, ServiceResult } from '../../shared/interfaces/service.result.js';
import { WhereCondition } from '../../shared/type/query-builder.types.js';

@Injectable()
export class MensajeService {
  constructor(
    @InjectRepository(MensajeWhatsApp)
    private repo: Repository<MensajeWhatsApp>,
  ) {}

  async findByPaquete(idPaquete: string): Promise<ServiceResult> {
    let serviceResult = defaultServiceResult();

    try {
      const result = await this.repo.find({
        where: { idPaquete },
        order: { fechaEnvio: 'DESC' },
      });

      serviceResult.boolean = result.length > 0;
      serviceResult.message = `${result.length} mensaje(s) encontrado(s).`;
      serviceResult.number = result.length;
      serviceResult.data = result;
    } catch (error: any) {
      serviceResult.boolean = false;
      serviceResult.message = `Error en el servicio: ${error.message}`;
    }

    return serviceResult;
  }

  async findPendientes(limit: number = 5): Promise<ServiceResult> {
    let serviceResult = defaultServiceResult();

    try {
      const mensajes = await this.repo.find({
        where: { estado: 'PENDIENTE' },
        order: { fechaCreacion: 'ASC' },
        take: limit,
      });

      if (mensajes.length === 0) {
        serviceResult.boolean = false;
        serviceResult.message = 'No hay mensajes pendientes.';
        serviceResult.number = 0;
        serviceResult.data = [];
        return serviceResult;
      }

      const data = mensajes.map(m => ({
        idMensajeWhatsApp: m.idMensajeWhatsApp,
        idPaquete: m.idPaquete,
        telefonoDestino: m.telefonoDestino,
        tipo: m.tipo,
        mensaje1: m.mensaje1,
        mensaje2: m.mensaje2,
        mensaje3: m.mensaje3,
        urlQR: m.urlQR,
        estado: m.estado,
        intentos: m.intentos,
        sessionId: m.sessionId,
        fechaCreacion: m.fechaCreacion,
      }));

      serviceResult.boolean = true;
      serviceResult.message = `${data.length} mensaje(s) pendiente(s).`;
      serviceResult.number = data.length;
      serviceResult.data = data;
    } catch (error: any) {
      serviceResult.boolean = false;
      serviceResult.message = `Error en el servicio: ${error.message}`;
    }

    return serviceResult;
  }

  async create(dto: MensajeWhatsAppDto): Promise<ServiceResult> {
    let serviceResult = defaultServiceResult();

    try {
      const mensaje = this.repo.create({
        ...dto,
      });
      const result = await this.repo.save(mensaje);

      serviceResult.boolean = true;
      serviceResult.message = 'Mensaje registrado correctamente.';
      serviceResult.number = 1;
      serviceResult.object = result;
    } catch (error: any) {
      serviceResult.boolean = false;
      serviceResult.message = `Error en el servicio: ${error.message}`;
    }

    return serviceResult;
  }

  async find(
    whereConditions: WhereCondition[],
    orderByAttribute: string,
    orderByDirection: 'ASC' | 'DESC',
    limit: number,
    offset: number,
  ): Promise<ServiceResult> {
    const serviceResult = defaultServiceResult();

    try {
      let query = this.repo.createQueryBuilder('mensaje');

      whereConditions.forEach((condition, index) => {
        const { attribute, value, operator = '=' } = condition;
        const paramKey = `param${index}`;
        const param = {
          [paramKey]: operator === 'like' ? `%${value}%` : value,
        };
        const whereMethod = index === 0 ? 'where' : 'andWhere';

        query = query[whereMethod](
          `mensaje.${attribute} ${operator} :${paramKey}`,
          param,
        );
      });

      query = query.orderBy(`mensaje.${orderByAttribute}`, orderByDirection);

      const totalRegistros = await query.getCount();
      const skip = (offset - 1) * limit;

      query = query.skip(skip).take(limit);

      const result = await query.getMany();
      const count = result.length;

      serviceResult.boolean = count > 0;
      serviceResult.message = `${count} Mensaje(s) encontrado(s).`;
      serviceResult.number = totalRegistros;
      serviceResult.data = result;
    } catch (error: any) {
      serviceResult.boolean = false;
      serviceResult.message = `Error en el servicio: ${error.message}`;
    }

    return serviceResult;
  }

  async updateEstado(id: string, dto: UpdateEstadoDto): Promise<ServiceResult> {
    let serviceResult = defaultServiceResult();

    try {
      const mensaje = await this.repo.findOne({ where: { idMensajeWhatsApp: id } });

      if (!mensaje) {
        serviceResult.message = `Mensaje ${id} no encontrado.`;
        return serviceResult;
      }

      mensaje.estado = dto.estado;
      if (dto.error) {
        mensaje.error = dto.error;
      }
      if (dto.fechaEnvio) {
        mensaje.fechaEnvio = new Date(dto.fechaEnvio);
      }
      if (dto.estado === 'PENDIENTE') {
        mensaje.intentos += 1;
      }

      const result = await this.repo.save(mensaje);

      serviceResult.boolean = true;
      serviceResult.message = 'Estado actualizado correctamente.';
      serviceResult.number = 1;
      serviceResult.object = result;
    } catch (error: any) {
      serviceResult.boolean = false;
      serviceResult.message = `Error en el servicio: ${error.message}`;
    }

    return serviceResult;
  }
}