// modules/invoice/infrastructure/invoice-dependencies.factory.ts

import type { IMapperRegistry, IPresenterRegistry, ModuleParams } from "@erp/core/api";

import {
  InMemoryMapperRegistry,
  InMemoryPresenterRegistry,
  SequelizeTransactionManager,
} from "@erp/core/api";

import {
  CreateCustomerInvoiceUseCase,
  CustomerInvoiceFullPresenter,
  CustomerInvoiceItemsFullPresenter,
  CustomerInvoiceReportHTMLPresenter,
  CustomerInvoiceReportPDFPresenter,
  CustomerInvoiceReportPresenter,
  GetCustomerInvoiceUseCase,
  ListCustomerInvoicesPresenter,
  ListCustomerInvoicesUseCase,
  RecipientInvoiceFullPresenter,
  ReportCustomerInvoiceUseCase,
} from "../application";

import { JsonTaxCatalogProvider, spainTaxCatalogProvider } from "@erp/core";
import { CustomerInvoiceService } from "../domain";
import { CustomerInvoiceDomainMapper, CustomerInvoiceListMapper } from "./mappers";
import { CustomerInvoiceRepository } from "./sequelize";

export type CustomerInvoiceDeps = {
  transactionManager: SequelizeTransactionManager;
  mapperRegistry: IMapperRegistry;
  presenterRegistry: IPresenterRegistry;
  repo: CustomerInvoiceRepository;
  service: CustomerInvoiceService;
  catalogs: {
    taxes: JsonTaxCatalogProvider;
  };
  build: {
    list: () => ListCustomerInvoicesUseCase;
    get: () => GetCustomerInvoiceUseCase;
    create: () => CreateCustomerInvoiceUseCase;
    //update: () => UpdateCustomerInvoiceUseCase;
    //delete: () => DeleteCustomerInvoiceUseCase;
    report: () => ReportCustomerInvoiceUseCase;
  };
};

export function buildCustomerInvoiceDependencies(params: ModuleParams): CustomerInvoiceDeps {
  const { database } = params;
  const transactionManager = new SequelizeTransactionManager(database);
  const catalogs = { taxes: spainTaxCatalogProvider };

  // Mapper Registry
  const mapperRegistry = new InMemoryMapperRegistry();
  mapperRegistry
    .registerDomainMapper(
      { resource: "customer-invoice" },
      new CustomerInvoiceDomainMapper({ taxCatalog: catalogs.taxes })
    )
    .registerQueryMappers([
      {
        key: { resource: "customer-invoice", query: "LIST" },
        mapper: new CustomerInvoiceListMapper(),
      },
    ]);

  // Repository & Services
  const repo = new CustomerInvoiceRepository({ mapperRegistry, database });
  const service = new CustomerInvoiceService(repo);

  // Presenter Registry
  const presenterRegistry = new InMemoryPresenterRegistry();
  presenterRegistry.registerPresenters([
    {
      key: {
        resource: "customer-invoice-items",
        projection: "FULL",
      },
      presenter: new CustomerInvoiceItemsFullPresenter(presenterRegistry),
    },
    {
      key: {
        resource: "recipient-invoice",
        projection: "FULL",
      },
      presenter: new RecipientInvoiceFullPresenter(presenterRegistry),
    },
    {
      key: {
        resource: "customer-invoice",
        projection: "FULL",
      },
      presenter: new CustomerInvoiceFullPresenter(presenterRegistry),
    },
    {
      key: {
        resource: "customer-invoice",
        projection: "LIST",
      },
      presenter: new ListCustomerInvoicesPresenter(presenterRegistry),
    },
    {
      key: {
        resource: "customer-invoice",
        projection: "REPORT",
        format: "JSON",
      },
      presenter: new CustomerInvoiceReportPresenter(presenterRegistry),
    },
    {
      key: {
        resource: "customer-invoice",
        projection: "REPORT",
        format: "HTML",
      },
      presenter: new CustomerInvoiceReportHTMLPresenter(presenterRegistry),
    },
    {
      key: {
        resource: "customer-invoice",
        projection: "REPORT",
        format: "PDF",
      },
      presenter: new CustomerInvoiceReportPDFPresenter(presenterRegistry),
    },
  ]);

  return {
    transactionManager,
    repo,
    mapperRegistry,
    presenterRegistry,
    service,
    catalogs,
    build: {
      list: () => new ListCustomerInvoicesUseCase(service, transactionManager, presenterRegistry),
      get: () => new GetCustomerInvoiceUseCase(service, transactionManager, presenterRegistry),
      create: () =>
        new CreateCustomerInvoiceUseCase(
          service,
          transactionManager,
          presenterRegistry,
          catalogs.taxes
        ),
      // update: () => new UpdateCustomerInvoiceUseCase(service, transactionManager),
      // delete: () => new DeleteCustomerInvoiceUseCase(service, transactionManager),
      report: () =>
        new ReportCustomerInvoiceUseCase(service, transactionManager, presenterRegistry),
    },
  };
}