import { type EmptyFields } from "@tailor-platform/erp-kit/core";
import type { TailorAnyDBField } from "@tailor-platform/sdk";
import type { TailorDBInsertable } from "@tailor-platform/sdk/kysely";
import type { BusinessPartnerModule } from "../business-partner";
import type { ItemManagementModule } from "../item-management";
import type { OrganizationModule } from "../organization";
import type { PrimitivesModule } from "../primitives";
import { amendConfirmedSalesOrder } from "./command/amendConfirmedSalesOrder.generated";
import { cancelSalesOrder } from "./command/cancelSalesOrder.generated";
import { closeSalesOrder } from "./command/closeSalesOrder.generated";
import { confirmSalesOrder } from "./command/confirmSalesOrder.generated";
import { createSalesItem } from "./command/createSalesItem.generated";
import { createSalesOrder } from "./command/createSalesOrder.generated";
import { deleteSalesItem } from "./command/deleteSalesItem.generated";
import { recalculateSalesOrderBillingStatus } from "./command/recalculateSalesOrderBillingStatus.generated";
import { recalculateSalesOrderFulfillmentStatus } from "./command/recalculateSalesOrderFulfillmentStatus.generated";
import { rejectSalesOrder } from "./command/rejectSalesOrder.generated";
import { submitSalesOrder } from "./command/submitSalesOrder.generated";
import { updateSalesItem } from "./command/updateSalesItem.generated";
import { updateSalesOrder } from "./command/updateSalesOrder.generated";
import { createSalesItemType, type CreateSalesItemTypeParams } from "./db/salesItem";
import { createSalesOrderType, type CreateSalesOrderTypeParams } from "./db/salesOrder";
import { createSalesOrderFieldChangeType } from "./db/salesOrderFieldChange";
import { createSalesOrderLineType, type CreateSalesOrderLineTypeParams } from "./db/salesOrderLine";
import { createSalesOrderRevisionType } from "./db/salesOrderRevision";
import { getSalesOrder } from "./query/getSalesOrder.generated";
import { listSalesOrders } from "./query/listSalesOrders.generated";

type OrganizationDB = OrganizationModule["db"];
export type OrganizationQueries = OrganizationModule["queries"];
type BusinessPartnerDB = BusinessPartnerModule["db"];
export type BusinessPartnerQueries = BusinessPartnerModule["queries"];
type ItemManagementDB = ItemManagementModule["db"];
export type ItemManagementQueries = ItemManagementModule["queries"];
type PrimitivesDB = PrimitivesModule["db"];

export interface DefineModuleParams<
  SoF extends Record<string, TailorAnyDBField> = EmptyFields,
  SolF extends Record<string, TailorAnyDBField> = EmptyFields,
  SiF extends Record<string, TailorAnyDBField> = EmptyFields,
> {
  salesItem?: CreateSalesItemTypeParams<SiF>;
  salesOrder?: CreateSalesOrderTypeParams<SoF>;
  salesOrderLine?: CreateSalesOrderLineTypeParams<SolF>;
  organization: {
    db: {
      company: OrganizationDB["company"];
    };
    queries: Pick<OrganizationQueries, "getCompany">;
  };
  businessPartner: {
    db: {
      customerAccount: BusinessPartnerDB["customerAccount"];
    };
    queries: Pick<BusinessPartnerQueries, "getCustomerAccount">;
  };
  itemManagement: {
    db: {
      item: ItemManagementDB["item"];
    };
    queries: Pick<ItemManagementQueries, "getItem">;
  };
  primitives: {
    db: {
      currency: PrimitivesDB["currency"];
      unit: PrimitivesDB["unit"];
    };
  };
}

/* @__NO_SIDE_EFFECTS__ */
export const defineModule = <
  const SoF extends Record<string, TailorAnyDBField> = EmptyFields,
  const SolF extends Record<string, TailorAnyDBField> = EmptyFields,
  const SiF extends Record<string, TailorAnyDBField> = EmptyFields,
>(
  params: DefineModuleParams<SoF, SolF, SiF>,
) => {
  const salesItemDb = createSalesItemType({
    ...params.salesItem,
    itemType: params.itemManagement.db.item,
  });
  const salesOrderDb = createSalesOrderType({
    ...params.salesOrder,
    companyType: params.organization.db.company,
    customerAccountType: params.businessPartner.db.customerAccount,
    currencyType: params.primitives.db.currency,
  });
  const salesOrderLineDb = createSalesOrderLineType({
    ...params.salesOrderLine,
    itemType: params.itemManagement.db.item,
    unitType: params.primitives.db.unit,
  });
  const salesOrderRevisionDb = createSalesOrderRevisionType({});
  const salesOrderFieldChangeDb = createSalesOrderFieldChangeType();

  return {
    db: {
      salesItem: salesItemDb,
      salesOrder: salesOrderDb,
      salesOrderLine: salesOrderLineDb,
      salesOrderRevision: salesOrderRevisionDb,
      salesOrderFieldChange: salesOrderFieldChangeDb,
    },
    commands: {
      amendConfirmedSalesOrder: amendConfirmedSalesOrder<
        TailorDBInsertable<SoF>,
        TailorDBInsertable<SolF>
      >(params.itemManagement.queries),
      cancelSalesOrder: cancelSalesOrder(),
      closeSalesOrder: closeSalesOrder(),
      confirmSalesOrder: confirmSalesOrder(params.businessPartner.queries),
      createSalesItem: createSalesItem<TailorDBInsertable<SiF>>(params.itemManagement.queries),
      createSalesOrder: createSalesOrder<TailorDBInsertable<SoF>, TailorDBInsertable<SolF>>(
        params.businessPartner.queries,
        params.itemManagement.queries,
        params.organization.queries,
      ),
      deleteSalesItem: deleteSalesItem(),
      recalculateSalesOrderBillingStatus: recalculateSalesOrderBillingStatus(),
      recalculateSalesOrderFulfillmentStatus: recalculateSalesOrderFulfillmentStatus(),
      rejectSalesOrder: rejectSalesOrder(),
      submitSalesOrder: submitSalesOrder(),
      updateSalesItem: updateSalesItem<TailorDBInsertable<SiF>>(),
      updateSalesOrder: updateSalesOrder<TailorDBInsertable<SoF>, TailorDBInsertable<SolF>>(
        params.itemManagement.queries,
        params.businessPartner.queries,
      ),
    },
    queries: {
      getSalesOrder,
      listSalesOrders,
    },
  };
};

/** EmptyFields-instantiated alias — use instead of `ReturnType<typeof defineModule>`, which widens field generics to their constraint. */
export type SalesModule = ReturnType<typeof defineModule<EmptyFields, EmptyFields, EmptyFields>>;