import { Criteria } from "@repo/rdx-criteria/server";
import { UniqueID } from "@repo/rdx-ddd";
import { Collection, Result } from "@repo/rdx-utils";
import { Transaction } from "sequelize";
import { CustomerInvoice, CustomerInvoiceProps } from "../aggregates";
import { ICustomerInvoiceRepository } from "../repositories";
import { ICustomerInvoiceService } from "./customer-invoice-service.interface";

export class CustomerInvoiceService implements ICustomerInvoiceService {
  constructor(private readonly repository: ICustomerInvoiceRepository) {}

  /**
   * Construye un nuevo agregado CustomerInvoice a partir de props validadas.
   *
   * @param props - Las propiedades ya validadas para crear la factura.
   * @param id - Identificador UUID de la factura (opcional).
   * @returns Result<CustomerInvoice, Error> - El agregado construido o un error si falla la creación.
   */
  build(props: CustomerInvoiceProps, id?: UniqueID): Result<CustomerInvoice, Error> {
    return CustomerInvoice.create(props, id);
  }

  /**
   * Guarda una instancia de CustomerInvoice en persistencia.
   *
   * @param invoice - El agregado a guardar.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoice, Error> - El agregado guardado o un error si falla la operación.
   */
  async save(invoice: CustomerInvoice, transaction: any): Promise<Result<CustomerInvoice, Error>> {
    const saved = await this.repository.save(invoice, transaction);
    return saved.isSuccess ? Result.ok(invoice) : Result.fail(saved.error);
  }

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

  async existsById(id: UniqueID, transaction?: any): Promise<Result<boolean, Error>> {
    return this.repository.existsById(id, transaction);
  }

  /**
   * Obtiene una colección de facturas que cumplen con los filtros definidos en un objeto Criteria.
   *
   * @param criteria - Objeto con condiciones de filtro, paginación y orden.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<Collection<CustomerInvoice>, Error> - Colección de facturas o error.
   */
  async findByCriteria(
    criteria: Criteria,
    transaction?: Transaction
  ): Promise<Result<Collection<CustomerInvoice>, Error>> {
    const customerInvoicesOrError = await this.repository.findAll(criteria, transaction);
    if (customerInvoicesOrError.isFailure) {
      return Result.fail(customerInvoicesOrError.error);
    }

    // Solo devolver usuarios activos
    //const allCustomerInvoices = customerInvoicesOrError.data.filter((customerInvoice) => customerInvoice.isActive);
    //return Result.ok(new Collection(allCustomerInvoices));

    return customerInvoicesOrError;
  }

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

  /**
   * Actualiza parcialmente una factura existente con nuevos datos.
   *
   * @param id - 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 updateById(
    customerInvoiceId: UniqueID,
    changes: Partial<CustomerInvoiceProps>,
    transaction?: Transaction
  ): Promise<Result<CustomerInvoice, Error>> {
    // Verificar si la factura existe
    const customerInvoiceOrError = await this.repository.getById(customerInvoiceId, transaction);
    if (customerInvoiceOrError.isFailure) {
      return Result.fail(new Error("CustomerInvoice not found"));
    }

    return Result.fail(new Error("No implementado"));

    /*const updatedCustomerInvoiceOrError = CustomerInvoice.update(customerInvoiceOrError.data, data);
    if (updatedCustomerInvoiceOrError.isFailure) {
      return Result.fail(
        new Error(`Error updating customerInvoice: ${updatedCustomerInvoiceOrError.error.message}`)
      );
    }

    const updateCustomerInvoice = updatedCustomerInvoiceOrError.data;

    await this.repo.update(updateCustomerInvoice, transaction);
    return Result.ok(updateCustomerInvoice);*/
  }

  async createCustomerInvoice(
    customerInvoiceId: UniqueID,
    data: CustomerInvoiceProps,
    transaction?: Transaction
  ): Promise<Result<CustomerInvoice, Error>> {
    // Verificar si la factura existe
    const customerInvoiceOrError = await this.repository.getById(customerInvoiceId, transaction);
    if (customerInvoiceOrError.isSuccess) {
      return Result.fail(new Error("CustomerInvoice exists"));
    }

    const newCustomerInvoiceOrError = CustomerInvoice.create(data, customerInvoiceId);
    if (newCustomerInvoiceOrError.isFailure) {
      return Result.fail(
        new Error(`Error creating customerInvoice: ${newCustomerInvoiceOrError.error.message}`)
      );
    }

    const newCustomerInvoice = newCustomerInvoiceOrError.data;

    await this.repository.create(newCustomerInvoice, transaction);
    return Result.ok(newCustomerInvoice);
  }

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