import { Injectable } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { PrismaService } from 'src/prisma/prisma.service';
import {
  CODIGO_CAMPO_REQUERIDO,
  CODIGO_DATOS_CAMBIADOS,
  conflicto,
  noEncontrado,
  solicitudInvalida,
} from 'src/common/utils/error-estructurado';
import { GuardarBorradorCompraDto } from './dto/guardar-borrador-compra.dto';

type Tx = Prisma.TransactionClient;

export const CODIGO_BORRADOR_NO_ENCONTRADO = 'BORRADOR_NO_ENCONTRADO';
export const CODIGO_BORRADOR_MUY_GRANDE = 'BORRADOR_MUY_GRANDE';
export const CODIGO_MONEDA_INVALIDA = 'MONEDA_INVALIDA';
/** Tope de `datos` serializado: una compra de miles de ítems no se puede pausar. */
export const MAX_BYTES_DATOS_BORRADOR = 256 * 1024;
/** "Tus borradores" muestra los últimos guardados, no todos. */
export const MAX_BORRADORES_LISTA = 50;

export type CodigoAvisoBorrador = 'PROVEEDOR_INACTIVO' | 'PRODUCTO_INACTIVO' | 'OC_NO_FACTURABLE';
export type AvisoBorrador = { codigo: CodigoAvisoBorrador; message: string; producto_id?: string };

/** Estados de OC desde los que se puede facturar (igual que `canUseInFacturaForEstado` del front). */
const ESTADOS_OC_FACTURABLES = new Set(['parcial']);

const SELECT_MONEDA = { select: { id: true, codigo: true } } as const;

const SELECT_RESUMEN = {
  id: true,
  proveedor_nombre: true,
  numero_comprobante: true,
  total: true,
  moneda_id: true,
  moneda: SELECT_MONEDA,
  created_at: true,
  updated_at: true,
} satisfies Prisma.compra_borradoresSelect;

const SELECT_BORRADOR = { ...SELECT_RESUMEN, datos: true } satisfies Prisma.compra_borradoresSelect;

export type BorradorResumen = Prisma.compra_borradoresGetPayload<{ select: typeof SELECT_RESUMEN }>;
export type BorradorCompra = Prisma.compra_borradoresGetPayload<{ select: typeof SELECT_BORRADOR }>;

const esObjeto = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
/**
 * Id de `datos` que se puede consultar. Un texto que no es UUID (el borrador es libre) se ignora
 * para los avisos: consultarlo daría un error de Prisma y el borrador no se podría abrir nunca.
 */
const uuidONulo = (v: unknown): string | null => (typeof v === 'string' && UUID.test(v) ? v : null);

/**
 * Borradores de factura de compra: el formulario a medio cargar de un usuario en su empresa.
 *
 * Todo filtra por `empresa_id` **y** `usuario_id` del token: el borrador de otro (o de la misma
 * persona en otra empresa) responde 404 como si no existiera. Un borrador no mueve stock, CxP,
 * OP, Tesorería, contabilidad ni OC; se borra (`consumirEnTx`) dentro de la transacción que
 * registra la compra, así que si la compra falla el borrador queda.
 */
@Injectable()
export class CompraBorradoresService {
  constructor(private readonly prisma: PrismaService) {}

  listar(empresaId: string, usuarioId: string): Promise<BorradorResumen[]> {
    return this.prisma.compra_borradores.findMany({
      where: { empresa_id: empresaId, usuario_id: usuarioId },
      select: SELECT_RESUMEN,
      orderBy: { updated_at: 'desc' },
      take: MAX_BORRADORES_LISTA,
    });
  }

  async obtener(id: string, empresaId: string, usuarioId: string): Promise<BorradorCompra & { avisos: AvisoBorrador[] }> {
    const borrador = await this.buscarPropio(id, empresaId, usuarioId);
    const avisos = await this.armarAvisos(borrador.datos, empresaId);
    return { ...borrador, avisos };
  }

  async crear(dto: GuardarBorradorCompraDto, empresaId: string, usuarioId: string): Promise<BorradorCompra> {
    this.validarTamano(dto.datos);
    await this.validarMoneda(dto.moneda_id, empresaId);
    const ahora = new Date();
    return this.prisma.compra_borradores.create({
      data: {
        empresa_id: empresaId,
        usuario_id: usuarioId,
        ...this.columnas(dto),
        // Con precisión de milisegundos (la de JS): `updated_at` es la versión que el front devuelve.
        created_at: ahora,
        updated_at: ahora,
      },
      select: SELECT_BORRADOR,
    });
  }

  async actualizar(id: string, dto: GuardarBorradorCompraDto, empresaId: string, usuarioId: string): Promise<BorradorCompra> {
    this.validarTamano(dto.datos);
    if (!dto.version) {
      throw solicitudInvalida({
        message: 'Falta la versión del borrador que se editó',
        codigo: CODIGO_CAMPO_REQUERIDO,
        campo: 'version',
      });
    }
    await this.validarMoneda(dto.moneda_id, empresaId);
    const version = new Date(dto.version);
    // Guardado condicionado a la versión leída: si otra pestaña guardó antes, no se pisa.
    const { count } = await this.prisma.compra_borradores.updateMany({
      where: { id, empresa_id: empresaId, usuario_id: usuarioId, updated_at: version },
      data: { ...this.columnas(dto), updated_at: new Date() },
    });
    if (count === 0) {
      await this.buscarPropio(id, empresaId, usuarioId);
      throw conflicto({
        message: 'El borrador se guardó desde otra pestaña o sesión. Recargalo para ver lo último.',
        codigo: CODIGO_DATOS_CAMBIADOS,
      });
    }
    return this.buscarPropio(id, empresaId, usuarioId);
  }

  async descartar(id: string, empresaId: string, usuarioId: string): Promise<{ id: string }> {
    const { count } = await this.prisma.compra_borradores.deleteMany({
      where: { id, empresa_id: empresaId, usuario_id: usuarioId },
    });
    if (count === 0) throw this.noEncontrado();
    return { id };
  }

  /**
   * Borra el borrador dentro de la transacción de la compra, solo si sigue en la `version` que el front leyó o guardó
   * por última vez: si otra pestaña lo guardó después, 409 DATOS_CAMBIADOS y la compra no se crea (no se pierde lo de
   * la otra pestaña). Ajeno o inexistente → 404.
   */
  async consumirEnTx(
    tx: Tx,
    id: string,
    version: string | undefined,
    empresaId: string,
    usuarioId: string | undefined,
  ): Promise<void> {
    // Sin usuario no hay dueño contra el cual filtrar: no se borra nada que no sea propio.
    if (!usuarioId) throw this.noEncontrado();
    if (!version) {
      throw solicitudInvalida({
        message: 'Falta la versión del borrador del que sale la compra',
        codigo: CODIGO_CAMPO_REQUERIDO,
        campo: 'borrador_version',
      });
    }
    const { count } = await tx.compra_borradores.deleteMany({
      where: { id, empresa_id: empresaId, usuario_id: usuarioId, updated_at: new Date(version) },
    });
    if (count > 0) return;
    const propio = await tx.compra_borradores.findFirst({
      where: { id, empresa_id: empresaId, usuario_id: usuarioId },
      select: { id: true },
    });
    if (!propio) throw this.noEncontrado();
    throw conflicto({
      message:
        'El borrador se guardó desde otra pestaña o sesión después de que lo abriste. Recargalo para ver lo último antes de registrar la compra.',
      codigo: CODIGO_DATOS_CAMBIADOS,
    });
  }

  private async buscarPropio(id: string, empresaId: string, usuarioId: string): Promise<BorradorCompra> {
    const borrador = await this.prisma.compra_borradores.findFirst({
      where: { id, empresa_id: empresaId, usuario_id: usuarioId },
      select: SELECT_BORRADOR,
    });
    if (!borrador) throw this.noEncontrado();
    return borrador;
  }

  private noEncontrado() {
    return noEncontrado({ message: 'El borrador no existe o ya se usó', codigo: CODIGO_BORRADOR_NO_ENCONTRADO });
  }

  private validarTamano(datos: unknown) {
    const bytes = Buffer.byteLength(JSON.stringify(datos ?? null), 'utf8');
    if (bytes > MAX_BYTES_DATOS_BORRADOR) {
      throw solicitudInvalida({
        message: 'El borrador es demasiado grande para guardarse',
        codigo: CODIGO_BORRADOR_MUY_GRANDE,
        campo: 'datos',
      });
    }
  }

  /** La moneda del resumen tiene que existir y estar habilitada en la empresa (si no, la FK daría 500). */
  private async validarMoneda(monedaId: string | undefined, empresaId: string) {
    if (!monedaId) return;
    const habilitada = await this.prisma.empresa_monedas.findFirst({
      where: { empresa_id: empresaId, moneda_id: monedaId, active: true },
      select: { id: true },
    });
    if (!habilitada) {
      throw solicitudInvalida({
        message: 'La moneda del borrador no está habilitada en la empresa',
        codigo: CODIGO_MONEDA_INVALIDA,
        campo: 'moneda_id',
      });
    }
  }

  private columnas(dto: GuardarBorradorCompraDto) {
    return {
      datos: dto.datos as Prisma.InputJsonValue,
      proveedor_nombre: dto.proveedor_nombre ?? null,
      numero_comprobante: dto.numero_comprobante ?? null,
      total: dto.total ?? null,
      moneda_id: dto.moneda_id ?? null,
    };
  }

  /**
   * Lo que cambió desde que se guardó el borrador y no deja registrar la compra tal cual.
   * `datos` es libre (puede venir incompleto o con otra forma): se lee a la defensiva.
   */
  private async armarAvisos(datos: unknown, empresaId: string): Promise<AvisoBorrador[]> {
    const cabecera = esObjeto(datos) && esObjeto(datos.cabecera) ? datos.cabecera : {};
    const items = esObjeto(datos) && Array.isArray(datos.items) ? datos.items : [];
    const proveedorId = uuidONulo(cabecera.proveedor_id);
    const ordenCompraId = uuidONulo(cabecera.orden_compra_id);
    const productoIds = [
      ...new Set(items.map((i) => (esObjeto(i) ? uuidONulo(i.producto_id) : null)).filter((v): v is string => !!v)),
    ];

    const [proveedor, productos, orden] = await Promise.all([
      proveedorId
        ? this.prisma.proveedores.findFirst({ where: { id: proveedorId, empresa_id: empresaId }, select: { activo: true } })
        : null,
      productoIds.length
        ? this.prisma.productos.findMany({
            where: { id: { in: productoIds }, empresa_id: empresaId },
            select: { id: true, active: true, deleted: true },
          })
        : [],
      ordenCompraId
        ? this.prisma.orden_compra_cab.findFirst({
            where: { id: ordenCompraId, empresa_id: empresaId },
            select: { estado: true, activo: true },
          })
        : null,
    ]);

    const avisos: AvisoBorrador[] = [];
    if (proveedorId && (!proveedor || proveedor.activo === false)) {
      avisos.push({ codigo: 'PROVEEDOR_INACTIVO', message: 'El proveedor del borrador ya no está activo' });
    }
    const usables = new Set(productos.filter((p) => p.active !== false && !p.deleted).map((p) => p.id));
    for (const productoId of productoIds) {
      if (!usables.has(productoId)) {
        avisos.push({
          codigo: 'PRODUCTO_INACTIVO',
          message: 'Un producto del borrador ya no está activo',
          producto_id: productoId,
        });
      }
    }
    const estadoOc = String(orden?.estado ?? '').toLowerCase();
    if (ordenCompraId && (!orden || orden.activo === false || !ESTADOS_OC_FACTURABLES.has(estadoOc))) {
      avisos.push({ codigo: 'OC_NO_FACTURABLE', message: 'La orden de compra del borrador ya no se puede facturar' });
    }
    return avisos;
  }
}
