import {
  type CommonReservedFields,
  type NoReservedFields,
  defaultGqlPermission,
  defaultPermission,
} from "@tailor-platform/erp-kit/core";
import { db, type TailorAnyDBField, type TailorAnyDBType } from "@tailor-platform/sdk";
import { accountReceivableDocument } from "./accountReceivableDocument";

const builtins = (params: { salesOrderLineType?: TailorAnyDBType; unitType?: TailorAnyDBType }) => {
  const salesOrderLineId = db
    .uuid({ optional: true })
    .description("Foreign key to SalesOrderLine for SALES_ORDER source lines");
  const unitId = db.uuid({ optional: true }).description("Customer invoice quantity unit");
  return {
    accountReceivableDocumentId: db
      .uuid()
      .relation({
        type: "n-1",
        toward: { type: accountReceivableDocument, as: "accountReceivableDocument" },
        backward: "lines",
      })
      .description("Foreign key to AccountReceivableDocument"),
    netAmount: db.decimal().description("Positive line amount excluding tax"),
    taxAmount: db.decimal({ optional: true }).description("Optional tax amount"),
    grossAmount: db.decimal().description("Positive line amount including tax"),
    correctionOfLineId: db
      .uuid({ optional: true })
      .relation({
        type: "n-1",
        toward: { type: "self" },
        backward: "correctionLines",
      })
      .description("Optional self-reference to the posted AR line being corrected"),
    correctionType: db
      .enum(["PRICE", "QUANTITY", "AMOUNT"] as const, { optional: true })
      .description("Optional correction type"),
    sourceType: db
      .enum(["SALES_ORDER"] as const, { optional: true })
      .description("Optional AR line source type"),
    salesOrderLineId: params.salesOrderLineType
      ? salesOrderLineId.relation({
          type: "n-1",
          toward: { type: params.salesOrderLineType, as: "salesOrderLine" },
          backward: "accountReceivableDocumentLines",
        })
      : salesOrderLineId,
    quantity: db
      .decimal({ optional: true })
      .description("Invoice quantity; required for SALES_ORDER source lines"),
    unitPrice: db
      .decimal({ optional: true })
      .description("Invoice unit price; required for SALES_ORDER source lines"),
    unitId: params.unitType
      ? unitId.relation({
          type: "n-1",
          toward: { type: params.unitType, as: "unit" },
          backward: "accountReceivableDocumentLines",
        })
      : unitId,
    description: db.string({ optional: true }).description("Optional line description"),
  };
};

type ReservedFields = keyof ReturnType<typeof builtins> | CommonReservedFields;

export interface CreateAccountReceivableDocumentLineTypeParams<
  F extends Record<string, TailorAnyDBField>,
> {
  fields?: NoReservedFields<F, ReservedFields>;
  salesOrderLineType?: TailorAnyDBType;
  unitType?: TailorAnyDBType;
}

export function createAccountReceivableDocumentLineType<
  const F extends Record<string, TailorAnyDBField>,
>(params: CreateAccountReceivableDocumentLineTypeParams<F>) {
  return db
    .table("AccountReceivableDocumentLine", {
      ...builtins(params),
      ...((params.fields ?? {}) as F),
      ...db.fields.timestamps(),
    })
    .permission(defaultPermission)
    .gqlPermission(defaultGqlPermission);
}

export const accountReceivableDocumentLine = createAccountReceivableDocumentLineType({});