import type { TailorAnyDBField } from "@tailor-platform/sdk";
import type { TailorDBInsertable } from "@tailor-platform/sdk/kysely";
import type { BusinessPartnerModule } from "../business-partner";
import type { InventoryModule } from "../inventory";
import type { ItemManagementModule } from "../item-management";
import type { OrganizationModule } from "../organization";
import type { PrimitivesModule } from "../primitives";
import type { UserManagementModule } from "../user-management";
import { amendOrderedPurchaseOrder } from "./command/amendOrderedPurchaseOrder.generated";
import { approvePurchaseOrder } from "./command/approvePurchaseOrder.generated";
import { cancelPurchaseOrder } from "./command/cancelPurchaseOrder.generated";
import { closePurchaseOrder } from "./command/closePurchaseOrder.generated";
import { createPurchaseItem } from "./command/createPurchaseItem.generated";
import { createPurchaseOrder } from "./command/createPurchaseOrder.generated";
import { deletePurchaseItem } from "./command/deletePurchaseItem.generated";
import { recalculatePurchaseOrderBillingStatus } from "./command/recalculatePurchaseOrderBillingStatus.generated";
import { recalculatePurchaseOrderReceiptStatus } from "./command/recalculatePurchaseOrderReceiptStatus.generated";
import { rejectPurchaseOrder } from "./command/rejectPurchaseOrder.generated";
import { submitPurchaseOrder } from "./command/submitPurchaseOrder.generated";
import { updatePurchaseItem } from "./command/updatePurchaseItem.generated";
import { updatePurchaseOrder } from "./command/updatePurchaseOrder.generated";
import { createPurchaseItemType, type CreatePurchaseItemTypeParams } from "./db/purchaseItem";
import { createPurchaseOrderType, type CreatePurchaseOrderTypeParams } from "./db/purchaseOrder";
import { createPurchaseOrderFieldChangeType } from "./db/purchaseOrderFieldChange";
import {
  createPurchaseOrderLineType,
  type CreatePurchaseOrderLineTypeParams,
} from "./db/purchaseOrderLine";
import { createPurchaseOrderRevisionType } from "./db/purchaseOrderRevision";
import { getPurchaseOrder } from "./query/getPurchaseOrder.generated";
import { listPurchaseOrderLinesForMatching } from "./query/listPurchaseOrderLinesForMatching.generated";

type OrganizationDB = OrganizationModule["db"];
export type OrganizationQueries = OrganizationModule["queries"];
type BusinessPartnerDB = BusinessPartnerModule["db"];
export type BusinessPartnerQueries = BusinessPartnerModule["queries"];
export type InventoryCommands = InventoryModule["commands"];
export type InventoryQueries = InventoryModule["queries"];
type ItemManagementDB = ItemManagementModule["db"];
export type ItemManagementQueries = ItemManagementModule["queries"];
type PrimitivesDB = PrimitivesModule["db"];
export type PrimitivesQueries = PrimitivesModule["queries"];
type UserManagementDB = UserManagementModule["db"];

export interface DefineModuleParams<
  POF extends Record<string, TailorAnyDBField>,
  POLF extends Record<string, TailorAnyDBField>,
  PIF extends Record<string, TailorAnyDBField>,
> {
  purchaseItem?: CreatePurchaseItemTypeParams<PIF>;
  purchaseOrder?: CreatePurchaseOrderTypeParams<POF>;
  purchaseOrderLine?: CreatePurchaseOrderLineTypeParams<POLF>;
  organization: {
    db: {
      company: OrganizationDB["company"];
      site: OrganizationDB["site"];
    };
    queries: Pick<OrganizationQueries, "getCompany" | "getSite">;
  };
  businessPartner: {
    db: {
      supplierAccount: BusinessPartnerDB["supplierAccount"];
    };
    queries: Pick<BusinessPartnerQueries, "getSupplierAccount">;
  };
  itemManagement: {
    db: {
      item: ItemManagementDB["item"];
    };
    queries: Pick<ItemManagementQueries, "getItem">;
  };
  primitives: {
    db: {
      currency: PrimitivesDB["currency"];
      unit: PrimitivesDB["unit"];
    };
  };
  inventory: {
    commands: {
      createInventorySupplyPlan: InventoryCommands["createInventorySupplyPlan"];
      updateInventorySupplyPlan: InventoryCommands["updateInventorySupplyPlan"];
      closeInventorySupplyPlan: InventoryCommands["closeInventorySupplyPlan"];
      postAcquisitionCostAdjustment: InventoryCommands["postAcquisitionCostAdjustment"];
    };
    queries: {
      getInventorySupplyPlan: InventoryQueries["getInventorySupplyPlan"];
    };
  };
  userManagement: {
    db: {
      user: UserManagementDB["user"];
    };
  };
}

/* @__NO_SIDE_EFFECTS__ */
export const defineModule = <
  const POF extends Record<string, TailorAnyDBField> = Record<never, never>,
  const POLF extends Record<string, TailorAnyDBField> = Record<never, never>,
  const PIF extends Record<string, TailorAnyDBField> = Record<never, never>,
>(
  params: DefineModuleParams<POF, POLF, PIF>,
) => {
  const purchaseItemDb = createPurchaseItemType({
    ...params.purchaseItem,
    itemType: params.itemManagement.db.item,
  });
  const purchaseOrderDb = createPurchaseOrderType({
    ...params.purchaseOrder,
    companyType: params.organization.db.company,
    supplierAccountType: params.businessPartner.db.supplierAccount,
    siteType: params.organization.db.site,
    currencyType: params.primitives.db.currency,
  });
  const purchaseOrderLineDb = createPurchaseOrderLineType({
    ...params.purchaseOrderLine,
    itemType: params.itemManagement.db.item,
    unitType: params.primitives.db.unit,
    siteType: params.organization.db.site,
  });
  const purchaseOrderRevisionDb = createPurchaseOrderRevisionType({
    userType: params.userManagement.db.user,
  });
  const purchaseOrderFieldChangeDb = createPurchaseOrderFieldChangeType();

  return {
    db: {
      purchaseItem: purchaseItemDb,
      purchaseOrder: purchaseOrderDb,
      purchaseOrderLine: purchaseOrderLineDb,
      purchaseOrderRevision: purchaseOrderRevisionDb,
      purchaseOrderFieldChange: purchaseOrderFieldChangeDb,
    },
    commands: {
      amendOrderedPurchaseOrder: amendOrderedPurchaseOrder<
        TailorDBInsertable<POF>,
        TailorDBInsertable<POLF>
      >(
        params.itemManagement.queries,
        params.inventory.commands,
        params.inventory.queries,
        params.organization.queries,
      ),
      approvePurchaseOrder: approvePurchaseOrder(
        params.businessPartner.queries,
        params.itemManagement.queries,
        params.inventory.commands,
      ),
      cancelPurchaseOrder: cancelPurchaseOrder(params.inventory.commands),
      closePurchaseOrder: closePurchaseOrder(params.inventory.commands),
      createPurchaseItem: createPurchaseItem<TailorDBInsertable<PIF>>(
        params.itemManagement.queries,
      ),
      createPurchaseOrder: createPurchaseOrder<TailorDBInsertable<POF>, TailorDBInsertable<POLF>>(
        params.businessPartner.queries,
        params.itemManagement.queries,
        params.organization.queries,
      ),
      deletePurchaseItem: deletePurchaseItem(),
      recalculatePurchaseOrderBillingStatus: recalculatePurchaseOrderBillingStatus(),
      recalculatePurchaseOrderReceiptStatus: recalculatePurchaseOrderReceiptStatus(),
      rejectPurchaseOrder: rejectPurchaseOrder(),
      updatePurchaseItem: updatePurchaseItem<TailorDBInsertable<PIF>>(),
      updatePurchaseOrder: updatePurchaseOrder<TailorDBInsertable<POF>, TailorDBInsertable<POLF>>(
        params.itemManagement.queries,
        params.organization.queries,
      ),
      submitPurchaseOrder: submitPurchaseOrder(params.businessPartner.queries),
    },
    queries: {
      getPurchaseOrder,
      listPurchaseOrderLinesForMatching,
    },
  };
};

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