import { BadRequestException, Injectable } from '@nestjs/common';
import { gym_modo_vencido, Prisma } from '@prisma/client';
import { AuditService } from 'src/audit/audit.service';
import { PrismaService } from 'src/prisma/prisma.service';
import { errorPlantilla, PLANTILLAS_POR_DEFECTO, TIPOS_AVISO } from '../avisos/avisos-plantillas';
import { textoONull } from '../common/gym-utils';
import { normalizarDiasAviso } from '../common/reglas';
import { UpdateConfigGymDto } from './dto/update-config.dto';
import { erroresHorarioSpa } from '../turnos/spa-reglas';

/**
 * Configuración del vertical: una fila por empresa con todo lo opcional apagado.
 * La fila nace sola la primera vez que se lee: sin paso manual post-deploy.
 */
@Injectable()
export class ConfigGymService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly audit: AuditService,
  ) {}

  async obtener(empresa_id: string) {
    const existente = await this.prisma.gym_config.findUnique({ where: { empresa_id } });
    if (existente) return existente;
    await this.prisma.gym_config.createMany({ data: [{ empresa_id }], skipDuplicates: true });
    return this.prisma.gym_config.findUniqueOrThrow({ where: { empresa_id } });
  }

  async actualizar(dto: UpdateConfigGymDto, empresa_id: string, user_id?: string) {
    const anterior = await this.obtener(empresa_id);
    const data: Record<string, unknown> = { ...dto };

    if (dto.cargo_transferencia_producto_id) {
      const p = await this.prisma.productos.findFirst({
        where: { id: dto.cargo_transferencia_producto_id, empresa_id, deleted: false },
        select: { id: true },
      });
      if (!p) throw new BadRequestException('El producto del cargo por transferencia no existe en esta empresa');
    }
    const permite = dto.permite_transferencia ?? anterior.permite_transferencia;
    const cargo =
      dto.cargo_transferencia_producto_id !== undefined
        ? dto.cargo_transferencia_producto_id
        : anterior.cargo_transferencia_producto_id;
    if (permite && !cargo) {
      throw new BadRequestException('Para permitir transferencias, elegí el producto del cargo por transferencia');
    }

    const modo = dto.modo_vencido ?? anterior.modo_vencido;
    const gracia = dto.dias_gracia ?? anterior.dias_gracia;
    if (modo === gym_modo_vencido.GRACIA_Y_BLOQUEO && gracia < 1) {
      throw new BadRequestException('Con gracia y bloqueo, los días de gracia tienen que ser al menos 1');
    }

    if (dto.avisos_dias_antes) data.avisos_dias_antes = normalizarDiasAviso(dto.avisos_dias_antes);
    if (dto.avisos_dias_despues) data.avisos_dias_despues = normalizarDiasAviso(dto.avisos_dias_despues);
    // Sin canales = avisos apagados (§15.13: «Enviar avisos de vencimiento» se puede apagar).
    if (dto.canales_aviso_vencimiento) data.canales_aviso_vencimiento = [...new Set(dto.canales_aviso_vencimiento)];
    if (dto.avisos_plantillas !== undefined) data.avisos_plantillas = normalizarPlantillas(dto.avisos_plantillas);
    if (dto.horario_spa !== undefined) {
      const errores = erroresHorarioSpa(dto.horario_spa);
      if (errores.length) throw new BadRequestException(errores);
      data.horario_spa = dto.horario_spa === null ? Prisma.DbNull : dto.horario_spa;
    }
    if (dto.reglamento !== undefined) data.reglamento = textoONull(dto.reglamento);
    if (dto.consentimiento !== undefined) data.consentimiento = textoONull(dto.consentimiento);

    const actualizado = await this.prisma.gym_config.update({
      where: { empresa_id },
      data: { ...data, updated_at: new Date() },
    });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'EDITAR',
      entity_type: 'gym_config',
      entity_id: actualizado.id,
      old_value: anterior as unknown as Record<string, unknown>,
      new_value: actualizado as unknown as Record<string, unknown>,
    });
    return actualizado;
  }
}

const ETIQUETAS_AVISO = { POR_VENCER: 'Aviso «por vencer»', VENCE_HOY: 'Aviso «vence hoy»', VENCIDA: 'Aviso «vencida»' } as const;

/**
 * Textos de los avisos para guardar: se valida cada uno y se guarda solo lo que difiere del texto original (así,
 * «Restaurar» es mandar el original o null, y una mejora futura del texto original les llega a quienes no lo editaron).
 */
export function normalizarPlantillas(entrada: Record<string, { asunto?: string; texto?: string }> | null) {
  if (!entrada) return Prisma.DbNull;
  const guardar: Record<string, { asunto: string; texto: string }> = {};
  for (const tipo of TIPOS_AVISO) {
    const p = entrada[tipo];
    if (!p) continue;
    const plantilla = { asunto: (p.asunto ?? '').trim(), texto: (p.texto ?? '').replace(/\r\n/g, '\n').trim() };
    const error = errorPlantilla(plantilla, ETIQUETAS_AVISO[tipo]);
    if (error) throw new BadRequestException(error);
    const original = PLANTILLAS_POR_DEFECTO[tipo];
    if (plantilla.asunto !== original.asunto || plantilla.texto !== original.texto) guardar[tipo] = plantilla;
  }
  return Object.keys(guardar).length ? guardar : Prisma.DbNull;
}
