import type { Criteria } from "@repo/rdx-criteria/server";
import type { UniqueID } from "@repo/rdx-ddd";
import { type Collection, Maybe, Result } from "@repo/rdx-utils";
import type { Transaction } from "sequelize";

import type {
  CustomerInvoiceNumber,
  CustomerInvoiceSerie,
  CustomerInvoiceStatus,
  ICustomerInvoiceNumberGenerator,
} from "../../domain";
import {
  CustomerInvoice,
  type CustomerInvoicePatchProps,
  type CustomerInvoiceProps,
} from "../../domain/aggregates";
import type { ICustomerInvoiceRepository } from "../../domain/repositories";
import type { CustomerInvoiceListDTO } from "../../infrastructure";

export class CustomerInvoiceApplicationService {
  constructor(
    private readonly repository: ICustomerInvoiceRepository,
    private readonly numberGenerator: ICustomerInvoiceNumberGenerator
  ) {}

  /**
   * Devuelve el siguiente nº para proformas
   *
   * @param companyId - Identificador de la empresa a la que pertenece la proforma.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoiceNumber, Error> - El agregado construido o un error si falla la creación.
   */
  async getNextProformaNumber(
    companyId: UniqueID,
    transaction: Transaction
  ): Promise<Result<CustomerInvoiceNumber, Error>> {
    return await this.numberGenerator.nextForCompany(companyId, Maybe.none(), transaction);
  }

  /**
   * Devuelve el siguiente nº para facturas (issue)
   *
   * @param companyId - Identificador de la empresa a la que pertenece la factura.
   * @param series - Serie por la que buscar la última factura
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoiceNumber, Error> - El agregado construido o un error si falla la creación.
   */
  async getNextIssueInvoiceNumber(
    companyId: UniqueID,
    series: Maybe<CustomerInvoiceSerie>,
    transaction: Transaction
  ): Promise<Result<CustomerInvoiceNumber, Error>> {
    return await this.numberGenerator.nextForCompany(companyId, series, transaction);
  }

  /**
   * Construye una proforma a partir de props validadas.
   *
   * @param companyId - Identificador de la empresa a la que pertenece la proforma.
   * @param props - Las propiedades ya validadas para crear la proforma.
   * @param proformaId - Identificador UUID de la proforma (opcional).
   * @returns Result<CustomerInvoice, Error> - El agregado construido o un error si falla la creación.
   */
  buildProformaInCompany(
    companyId: UniqueID,
    props: Omit<CustomerInvoiceProps, "companyId">,
    proformaId?: UniqueID
  ): Result<CustomerInvoice, Error> {
    return CustomerInvoice.create({ ...props, companyId }, proformaId);
  }

  /**
   * Guarda una nueva proforma y devuelve la proforma guardada.
   *
   * @param companyId - Identificador de la empresa a la que pertenece la proforma.
   * @param proforma - La proforma a guardar.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoice, Error> - La proforma guardada o un error si falla la operación.
   */
  async createInvoiceInCompany(
    companyId: UniqueID,
    proforma: CustomerInvoice,
    transaction: Transaction
  ): Promise<Result<CustomerInvoice, Error>> {
    const result = await this.repository.create(proforma, transaction);
    if (result.isFailure) {
      return Result.fail(result.error);
    }

    return this.getProformaByIdInCompany(companyId, proforma.id, transaction);
  }

  /**
   * Actualiza una proforma existente y devuelve la proforma actualizada.
   *
   * @param companyId - Identificador de la empresa a la que pertenece la factura.
   * @param proforma - La proforma a guardar.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoice, Error> - La proforma guardada o un error si falla la operación.
   */
  async updateProformaInCompany(
    companyId: UniqueID,
    proforma: CustomerInvoice,
    transaction: Transaction
  ): Promise<Result<CustomerInvoice, Error>> {
    const result = await this.repository.update(proforma, transaction);
    if (result.isFailure) {
      return Result.fail(result.error);
    }

    return this.getProformaByIdInCompany(companyId, proforma.id, transaction);
  }

  /**
   *
   * Comprueba si existe o no en persistencia una factura con el ID proporcionado
   *
   * @param companyId - Identificador de la empresa a la que pertenece la factura.
   * @param invoiceId - Identificador UUID de la factura.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<Boolean, Error> - Existe la factura o no.
   */

  async existsByIdInCompany(
    companyId: UniqueID,
    invoiceId: UniqueID,
    transaction?: Transaction
  ): Promise<Result<boolean, Error>> {
    return this.repository.existsByIdInCompany(companyId, invoiceId, transaction);
  }

  /**
   * Obtiene una colección de facturas que cumplen con los filtros definidos en un objeto Criteria.
   *
   * @param companyId - Identificador de la empresa a la que pertenece la factura.
   * @param criteria - Objeto con condiciones de filtro, paginación y orden.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<Collection<CustomerInvoiceListDTO>, Error> - Colección de facturas o error.
   */
  async findInvoiceByCriteriaInCompany(
    companyId: UniqueID,
    criteria: Criteria,
    transaction?: Transaction
  ): Promise<Result<Collection<CustomerInvoiceListDTO>, Error>> {
    return this.repository.findByCriteriaInCompany(companyId, criteria, transaction);
  }

  /**
   * Recupera una factura por su identificador único.
   *
   * @param invoiceId - Identificador UUID de la factura.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoice, Error> - Factura encontrada o error.
   */
  async getIssueInvoiceByIdInCompany(
    companyId: UniqueID,
    invoiceId: UniqueID,
    transaction?: Transaction
  ): Promise<Result<CustomerInvoice>> {
    return await this.repository.getByIdInCompany(companyId, invoiceId, transaction, {
      where: {
        is_proforma: false,
      },
    });
  }

  /**
   * Recupera una proforma por su identificador único.
   *
   * @param proformaId - Identificador UUID de la proforma.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoice, Error> - proforma encontrada o error.
   */
  async getProformaByIdInCompany(
    companyId: UniqueID,
    proformaId: UniqueID,
    transaction?: Transaction
  ): Promise<Result<CustomerInvoice>> {
    return await this.repository.getByIdInCompany(companyId, proformaId, transaction, {
      where: {
        is_proforma: true,
      },
    });
  }

  /**
   * Actualiza parcialmente una factura existente con nuevos datos.
   * No lo guarda en el repositorio.
   *
   * @param companyId - Identificador de la empresa a la que pertenece la factura.
   * @param proformaId - Identificador de la factura a actualizar.
   * @param changes - Subconjunto de props válidas para aplicar.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoice, Error> - Factura actualizada o error.
   */
  async patchProformaByIdInCompany(
    companyId: UniqueID,
    proformaId: UniqueID,
    changes: CustomerInvoicePatchProps,
    transaction?: Transaction
  ): Promise<Result<CustomerInvoice, Error>> {
    const invoiceResult = await this.getProformaByIdInCompany(companyId, proformaId, transaction);

    if (invoiceResult.isFailure) {
      return Result.fail(invoiceResult.error);
    }

    const updated = invoiceResult.data.update(changes);

    if (updated.isFailure) {
      return Result.fail(updated.error);
    }

    return Result.ok(updated.data);
  }

  /**
   * Elimina (o marca como eliminada) una factura según su ID.
   *
   * @param companyId - Identificador de la empresa a la que pertenece la factura.
   * @param invoiceId - Identificador UUID de la factura.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<boolean, Error> - Resultado de la operación.
   */
  async deleteInvoiceByIdInCompany(
    companyId: UniqueID,
    invoiceId: UniqueID,
    transaction?: Transaction
  ): Promise<Result<boolean, Error>> {
    return this.repository.deleteByIdInCompany(companyId, invoiceId, transaction);
  }

  /**
   *
   * Actualiza el "status" de una proforma
   *
   * @param companyId - Identificador UUID de la empresa a la que pertenece el cliente.
   * @param proformaId - UUID de la factura a eliminar.
   * @param newStatus - nuevo estado
   * @param transaction - Transacción activa para la operación.
   * @returns Result<boolean, Error>
   */
  async updateProformaStatusByIdInCompany(
    companyId: UniqueID,
    proformaId: UniqueID,
    newStatus: CustomerInvoiceStatus,
    transaction?: Transaction
  ): Promise<Result<boolean, Error>> {
    return this.repository.updateProformaStatusByIdInCompany(
      companyId,
      proformaId,
      newStatus,
      transaction
    );
  }
}