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 { InventoryModule } from "../inventory";
import type { ItemManagementModule } from "../item-management";
import type { PrimitivesModule } from "../primitives";
import type { SalesModule } from "../sales";
import { cancelOutboundShipment } from "./command/cancelOutboundShipment.generated";
import { createOutboundShipment } from "./command/createOutboundShipment.generated";
import { postOutboundShipment } from "./command/postOutboundShipment.generated";
import { updateOutboundShipment } from "./command/updateOutboundShipment.generated";
import {
  createOutboundShipmentType,
  type CreateOutboundShipmentTypeParams,
} from "./db/outboundShipment";
import {
  createOutboundShipmentLineType,
  type CreateOutboundShipmentLineTypeParams,
} from "./db/outboundShipmentLine";
import { getOutboundShipment } from "./query/getOutboundShipment.generated";
import { listOutboundShipments } from "./query/listOutboundShipments.generated";

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

type PrimitivesDB = PrimitivesModule["db"];

type InventoryDB = InventoryModule["db"];
export type InventoryCommands = InventoryModule["commands"];
export type InventoryQueries = InventoryModule["queries"];
export type SalesCommands = SalesModule["commands"];

export interface DefineModuleParams<
  OSF extends Record<string, TailorAnyDBField> = EmptyFields,
  OSLF extends Record<string, TailorAnyDBField> = EmptyFields,
> {
  outboundShipment?: CreateOutboundShipmentTypeParams<OSF>;
  outboundShipmentLine?: Omit<
    CreateOutboundShipmentLineTypeParams<OSLF>,
    "itemType" | "unitType" | "storageLocationType"
  >;
  itemManagement: {
    db: { item: ItemManagementDB["item"] };
    queries: Pick<ItemManagementQueries, "getItem">;
  };
  primitives: {
    db: { unit: PrimitivesDB["unit"] };
  };
  inventory: {
    db: {
      storageLocation: InventoryDB["storageLocation"];
    };
    commands: Pick<InventoryCommands, "postInventoryLedger">;
    queries: Pick<InventoryQueries, "getStorageLocation">;
  };
  sales: {
    commands: Pick<SalesCommands, "recalculateSalesOrderFulfillmentStatus">;
  };
}

/* @__NO_SIDE_EFFECTS__ */
export const defineModule = <
  const OSF extends Record<string, TailorAnyDBField> = EmptyFields,
  const OSLF extends Record<string, TailorAnyDBField> = EmptyFields,
>(
  params: DefineModuleParams<OSF, OSLF>,
) => {
  const outboundShipment = createOutboundShipmentType({
    ...params.outboundShipment,
  });
  const outboundShipmentLine = createOutboundShipmentLineType({
    ...params.outboundShipmentLine,
    itemType: params.itemManagement.db.item,
    unitType: params.primitives.db.unit,
    storageLocationType: params.inventory.db.storageLocation,
  });

  const itemQueries = params.itemManagement.queries;
  const inventoryQueries = params.inventory.queries;

  return {
    db: {
      outboundShipment,
      outboundShipmentLine,
    },
    queries: {
      getOutboundShipment,
      listOutboundShipments,
    },
    commands: {
      createOutboundShipment: createOutboundShipment<
        TailorDBInsertable<OSF>,
        TailorDBInsertable<OSLF>
      >(itemQueries, inventoryQueries),
      updateOutboundShipment: updateOutboundShipment<
        TailorDBInsertable<OSF>,
        TailorDBInsertable<OSLF>
      >(itemQueries, inventoryQueries),
      cancelOutboundShipment: cancelOutboundShipment(),
      postOutboundShipment: postOutboundShipment(params.inventory.commands, params.sales.commands),
    },
  };
};

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