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

export const BANK_STATEMENT_LINE_FLOW_DIRECTIONS = ["CREDIT", "DEBIT"] as const;
export const BANK_STATEMENT_LINE_RECONCILIATION_STATUSES = ["UNRECONCILED", "RECONCILED"] as const;

const builtins = (params: { bankReconciliationType: TailorAnyDBType }) => ({
  bankStatementId: db
    .uuid()
    .relation({
      type: "n-1",
      toward: { type: bankStatement, as: "bankStatement" },
      backward: "lines",
    })
    .description("Foreign key to BankStatement"),
  lineNumber: db.int().description("Line number within the bank statement"),
  bookingDate: db.date().description("Date booked by the bank"),
  valueDate: db.date({ optional: true }).description("Optional bank value date"),
  flowDirection: db
    .enum(BANK_STATEMENT_LINE_FLOW_DIRECTIONS)
    .description("CREDIT for money in and DEBIT for money out"),
  amount: db.decimal().description("Positive statement-line amount"),
  reconciliationStatus: db
    .enum(BANK_STATEMENT_LINE_RECONCILIATION_STATUSES)
    .description("Current bank reconciliation status, separate from document lifecycle status"),
  currentBankReconciliationId: db
    .uuid({ optional: true })
    .relation({
      type: "n-1",
      toward: { type: params.bankReconciliationType, as: "currentBankReconciliation" },
      backward: "currentStatementLines",
    })
    .description("Current effective BankReconciliation; null when unreconciled"),
  bankReference: db.string({ optional: true }).description("Bank transaction reference"),
  endToEndId: db.string({ optional: true }).description("End-to-end payment identifier"),
  counterpartyName: db.string({ optional: true }).description("Counterparty display name"),
  counterpartyAccount: db
    .string({ optional: true })
    .description("Masked or bank-provided counterparty account"),
  description: db.string({ optional: true }).description("Bank statement narrative"),
});

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

export interface CreateBankStatementLineTypeParams<F extends Record<string, TailorAnyDBField>> {
  fields?: NoReservedFields<F, ReservedFields>;
  bankReconciliationType?: TailorAnyDBType;
}

export function createBankStatementLineType<const F extends Record<string, TailorAnyDBField>>(
  params: CreateBankStatementLineTypeParams<F>,
) {
  return db
    .table("BankStatementLine", {
      ...builtins({
        bankReconciliationType: params.bankReconciliationType ?? bankReconciliation,
      }),
      ...((params.fields ?? {}) as F),
      ...db.fields.timestamps(),
    })
    .indexes({
      fields: ["bankStatementId", "lineNumber"],
      unique: true,
      name: "bank_statement_line_number_uq",
    })
    .permission(defaultPermission)
    .gqlPermission(defaultGqlPermission);
}

export const bankStatementLine = createBankStatementLineType({});