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 { CoaManagementModule } from "../coa-management";
import type { FinancialAccountingModule } from "../financial-accounting";
import type { ItemManagementModule } from "../item-management";
import type { OrganizationModule } from "../organization";
import type { PrimitivesModule } from "../primitives";
import { cancelStockAdjustment } from "./command/cancelStockAdjustment.generated";
import { closeInventorySupplyPlan } from "./command/closeInventorySupplyPlan.generated";
import { closeStockReservation } from "./command/closeStockReservation.generated";
import { closeTransferOrder } from "./command/closeTransferOrder.generated";
import { confirmStockAdjustment } from "./command/confirmStockAdjustment.generated";
import { createInventorySupplyPlan } from "./command/createInventorySupplyPlan.generated";
import { createStockAdjustment } from "./command/createStockAdjustment.generated";
import { createStockReservation } from "./command/createStockReservation.generated";
import { createStorageLocation } from "./command/createStorageLocation.generated";
import { createTransferOrder } from "./command/createTransferOrder.generated";
import { createValuationPolicy } from "./command/createValuationPolicy.generated";
import { deactivateStorageLocation } from "./command/deactivateStorageLocation.generated";
import { openTransferOrder } from "./command/openTransferOrder.generated";
import { postAcquisitionCostAdjustment } from "./command/postAcquisitionCostAdjustment.generated";
import { postInventoryLedger } from "./command/postInventoryLedger.generated";
import { publishStandardCost } from "./command/publishStandardCost.generated";
import { reactivateStorageLocation } from "./command/reactivateStorageLocation.generated";
import { receiveTransferOrder } from "./command/receiveTransferOrder.generated";
import { rejectStockAdjustment } from "./command/rejectStockAdjustment.generated";
import { setItemValuationPolicy } from "./command/setItemValuationPolicy.generated";
import { shipTransferOrder } from "./command/shipTransferOrder.generated";
import { submitStockAdjustment } from "./command/submitStockAdjustment.generated";
import { updateInventorySupplyPlan } from "./command/updateInventorySupplyPlan.generated";
import { updateStockAdjustment } from "./command/updateStockAdjustment.generated";
import { updateStockReservation } from "./command/updateStockReservation.generated";
import { updateStorageLocation } from "./command/updateStorageLocation.generated";
import { updateTransferOrder } from "./command/updateTransferOrder.generated";
import { updateValuationPolicy } from "./command/updateValuationPolicy.generated";
import { createAcquisitionCostAdjustmentType } from "./db/acquisitionCostAdjustment";
import { createAcquisitionCostAdjustmentAllocationType } from "./db/acquisitionCostAdjustmentAllocation";
import { createAverageCostType } from "./db/averageCost";
import { createCostLayerType } from "./db/costLayer";
import { createCostLayerConsumptionType } from "./db/costLayerConsumption";
import { createFifoCostType } from "./db/fifoCost";
import { createInventoryLedgerType } from "./db/inventoryLedger";
import {
  createInventorySupplyPlanType,
  type CreateInventorySupplyPlanTypeParams,
} from "./db/inventorySupplyPlan";
import { createItemValuationType } from "./db/itemValuation";
import { createStandardCostType } from "./db/standardCost";
import { createStockAdjustmentType } from "./db/stockAdjustment";
import { createStockAdjustmentLineType } from "./db/stockAdjustmentLine";
import { createStockLevelType } from "./db/stockLevel";
import { createStockReservationType } from "./db/stockReservation";
import {
  createStorageLocationType,
  type CreateStorageLocationTypeParams,
} from "./db/storageLocation";
import { createTransferOrderType, type CreateTransferOrderTypeParams } from "./db/transferOrder";
import {
  createTransferOrderLineType,
  type CreateTransferOrderLineTypeParams,
} from "./db/transferOrderLine";
import { createValuationPolicyType } from "./db/valuationPolicy";
import { getInventorySupplyPlan } from "./query/getInventorySupplyPlan.generated";
import { getItemValuation } from "./query/getItemValuation.generated";
import { getSiteStockSummary } from "./query/getSiteStockSummary.generated";
import { getStockAdjustment } from "./query/getStockAdjustment.generated";
import { getStockLevel } from "./query/getStockLevel.generated";
import { getStorageLocation } from "./query/getStorageLocation.generated";
import { getTransferOrder } from "./query/getTransferOrder.generated";
import { getValuationPolicy } from "./query/getValuationPolicy.generated";
import { listInventorySupplyPlans } from "./query/listInventorySupplyPlans.generated";
import { listItemValuations } from "./query/listItemValuations.generated";
import { listStockAdjustments } from "./query/listStockAdjustments.generated";
import { listStockLevels } from "./query/listStockLevels.generated";
import { listStorageLocations } from "./query/listStorageLocations.generated";
import { listTransferOrders } from "./query/listTransferOrders.generated";
import { listValuationPolicies } from "./query/listValuationPolicies.generated";
import { resolveItemValuationPolicies } from "./query/resolveItemValuationPolicies.generated";

type OrganizationDB = OrganizationModule["db"];
export type OrganizationQueries = OrganizationModule["queries"];

type ItemManagementDB = ItemManagementModule["db"];
export type ItemManagementQueries = ItemManagementModule["queries"];

type PrimitivesDB = PrimitivesModule["db"];

export type FinancialAccountingCommands = FinancialAccountingModule["commands"];
export type FinancialAccountingQueries = FinancialAccountingModule["queries"];

export type CoaManagementQueries = CoaManagementModule["queries"];

export interface DefineModuleParams<
  SF extends Record<string, TailorAnyDBField> = EmptyFields,
  ISPF extends Record<string, TailorAnyDBField> = EmptyFields,
  TOF extends Record<string, TailorAnyDBField> = EmptyFields,
  TOLF extends Record<string, TailorAnyDBField> = EmptyFields,
> {
  storageLocation?: Omit<CreateStorageLocationTypeParams<SF>, "siteType">;
  inventorySupplyPlan?: Omit<CreateInventorySupplyPlanTypeParams<ISPF>, "itemType" | "siteType">;
  transferOrder?: Omit<CreateTransferOrderTypeParams<TOF>, "siteType">;
  transferOrderLine?: Omit<CreateTransferOrderLineTypeParams<TOLF>, "itemType" | "unitType">;
  organization: {
    db: { company: OrganizationDB["company"]; site: OrganizationDB["site"] };
    queries: {
      getCompany: OrganizationQueries["getCompany"];
      getSite: OrganizationQueries["getSite"];
    };
  };
  itemManagement: {
    db: { item: ItemManagementDB["item"] };
    queries: { getItem: ItemManagementQueries["getItem"] };
  };
  primitives: {
    db: { unit: PrimitivesDB["unit"] };
  };
  financialAccounting: {
    commands: Pick<FinancialAccountingCommands, "createJournalEntry" | "postJournalEntry">;
    queries: Pick<FinancialAccountingQueries, "getPeriodByDate">;
  };
  coaManagement: {
    queries: Pick<CoaManagementQueries, "listAccounts">;
  };
}

/* @__NO_SIDE_EFFECTS__ */
export const defineModule = <
  const SF extends Record<string, TailorAnyDBField> = EmptyFields,
  const ISPF extends Record<string, TailorAnyDBField> = EmptyFields,
  const TOF extends Record<string, TailorAnyDBField> = EmptyFields,
  const TOLF extends Record<string, TailorAnyDBField> = EmptyFields,
>(
  params: DefineModuleParams<SF, ISPF, TOF, TOLF>,
) => {
  const storageLocation = createStorageLocationType({
    ...params.storageLocation,
    siteType: params.organization.db.site,
  });
  const valuationPolicy = createValuationPolicyType({
    companyType: params.organization.db.company,
  });
  const stockLevel = createStockLevelType({ itemType: params.itemManagement.db.item });
  const stockReservation = createStockReservationType({
    itemType: params.itemManagement.db.item,
    siteType: params.organization.db.site,
  });
  const inventorySupplyPlan = createInventorySupplyPlanType({
    ...params.inventorySupplyPlan,
    itemType: params.itemManagement.db.item,
    siteType: params.organization.db.site,
  });
  const stockAdjustment = createStockAdjustmentType({});
  const stockAdjustmentLine = createStockAdjustmentLineType({
    itemType: params.itemManagement.db.item,
  });
  const transferOrder = createTransferOrderType({
    ...params.transferOrder,
    siteType: params.organization.db.site,
  });
  const transferOrderLine = createTransferOrderLineType({
    ...params.transferOrderLine,
    itemType: params.itemManagement.db.item,
    unitType: params.primitives.db.unit,
  });
  const inventoryLedger = createInventoryLedgerType({ itemType: params.itemManagement.db.item });
  const itemValuation = createItemValuationType({
    itemType: params.itemManagement.db.item,
    companyType: params.organization.db.company,
  });
  const standardCost = createStandardCostType({ itemType: params.itemManagement.db.item });
  const costLayer = createCostLayerType({
    itemType: params.itemManagement.db.item,
    companyType: params.organization.db.company,
  });
  const costLayerConsumption = createCostLayerConsumptionType();
  const fifoCost = createFifoCostType();
  const averageCost = createAverageCostType({
    itemType: params.itemManagement.db.item,
    companyType: params.organization.db.company,
  });
  const acquisitionCostAdjustment = createAcquisitionCostAdjustmentType({});
  const acquisitionCostAdjustmentAllocation = createAcquisitionCostAdjustmentAllocationType();

  const orgQueries = params.organization.queries;
  const itemQueries = params.itemManagement.queries;
  const finAcctCommands = params.financialAccounting.commands;
  const finAcctQueries = params.financialAccounting.queries;
  const coaQueries = params.coaManagement.queries;

  return {
    db: {
      storageLocation,
      valuationPolicy,
      stockLevel,
      stockReservation,
      inventorySupplyPlan,
      stockAdjustment,
      stockAdjustmentLine,
      transferOrder,
      transferOrderLine,
      inventoryLedger,
      itemValuation,
      standardCost,
      costLayer,
      costLayerConsumption,
      fifoCost,
      averageCost,
      acquisitionCostAdjustment,
      acquisitionCostAdjustmentAllocation,
    },
    queries: {
      getStorageLocation,
      getValuationPolicy,
      getStockLevel,
      getInventorySupplyPlan,
      getStockAdjustment,
      getTransferOrder,
      getItemValuation,
      getSiteStockSummary,
      listStorageLocations,
      listValuationPolicies,
      listStockLevels,
      listInventorySupplyPlans,
      listStockAdjustments,
      listTransferOrders,
      listItemValuations,
      resolveItemValuationPolicies,
    },
    commands: {
      createStorageLocation: createStorageLocation<TailorDBInsertable<SF>>(orgQueries),
      updateStorageLocation: updateStorageLocation(),
      deactivateStorageLocation: deactivateStorageLocation(),
      reactivateStorageLocation: reactivateStorageLocation(orgQueries),
      createValuationPolicy: createValuationPolicy(orgQueries, coaQueries),
      updateValuationPolicy: updateValuationPolicy(coaQueries),
      setItemValuationPolicy: setItemValuationPolicy(itemQueries, orgQueries),
      publishStandardCost: publishStandardCost(finAcctCommands, finAcctQueries),
      postInventoryLedger: postInventoryLedger(
        itemQueries,
        orgQueries,
        finAcctCommands,
        finAcctQueries,
      ),
      postAcquisitionCostAdjustment: postAcquisitionCostAdjustment(finAcctCommands, finAcctQueries),
      createInventorySupplyPlan: createInventorySupplyPlan<TailorDBInsertable<ISPF>>(
        itemQueries,
        orgQueries,
      ),
      updateInventorySupplyPlan: updateInventorySupplyPlan<TailorDBInsertable<ISPF>>(
        itemQueries,
        orgQueries,
      ),
      closeInventorySupplyPlan: closeInventorySupplyPlan(),
      createStockAdjustment: createStockAdjustment(itemQueries),
      updateStockAdjustment: updateStockAdjustment(itemQueries),
      submitStockAdjustment: submitStockAdjustment(itemQueries),
      confirmStockAdjustment: confirmStockAdjustment(
        itemQueries,
        orgQueries,
        finAcctCommands,
        finAcctQueries,
      ),
      rejectStockAdjustment: rejectStockAdjustment(),
      cancelStockAdjustment: cancelStockAdjustment(),
      closeStockReservation: closeStockReservation(),
      createStockReservation: createStockReservation(itemQueries, orgQueries),
      updateStockReservation: updateStockReservation(itemQueries, orgQueries),
      createTransferOrder: createTransferOrder<TailorDBInsertable<TOF>, TailorDBInsertable<TOLF>>(
        itemQueries,
        orgQueries,
      ),
      updateTransferOrder: updateTransferOrder<TailorDBInsertable<TOF>, TailorDBInsertable<TOLF>>(
        itemQueries,
        orgQueries,
      ),
      openTransferOrder: openTransferOrder(),
      shipTransferOrder: shipTransferOrder(
        itemQueries,
        orgQueries,
        finAcctCommands,
        finAcctQueries,
      ),
      receiveTransferOrder: receiveTransferOrder(
        itemQueries,
        orgQueries,
        finAcctCommands,
        finAcctQueries,
      ),
      closeTransferOrder: closeTransferOrder(),
    },
  };
};

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