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 { AccountPayableModule } from "../account-payable";
import type { AccountReceivableModule } from "../account-receivable";
import type { CoaManagementModule } from "../coa-management";
import type { FinancialAccountingModule } from "../financial-accounting";
import type { OrganizationModule } from "../organization";
import type { PrimitivesModule } from "../primitives";
import { createBankAccount } from "./command/createBankAccount.generated";
import { createBankStatement } from "./command/createBankStatement.generated";
import { reconcileBankTransactions } from "./command/reconcileBankTransactions.generated";
import { reverseBankReconciliation } from "./command/reverseBankReconciliation.generated";
import { createBankAccountType, type CreateBankAccountTypeParams } from "./db/bankAccount";
import { createBankReconciliationType } from "./db/bankReconciliation";
import { createBankReconciliationItemType } from "./db/bankReconciliationItem";
import { createBankStatementType, type CreateBankStatementTypeParams } from "./db/bankStatement";
import {
  createBankStatementLineType,
  type CreateBankStatementLineTypeParams,
} from "./db/bankStatementLine";

type OrganizationDB = OrganizationModule["db"];
export type OrganizationQueries = OrganizationModule["queries"];
type PrimitivesDB = PrimitivesModule["db"];
export type PrimitivesQueries = PrimitivesModule["queries"];
type CoaManagementDB = CoaManagementModule["db"];
export type CoaManagementQueries = CoaManagementModule["queries"];
export type AccountReceivableQueries = AccountReceivableModule["queries"];
export type AccountPayableQueries = AccountPayableModule["queries"];
export type FinancialAccountingCommands = FinancialAccountingModule["commands"];
export type FinancialAccountingQueries = FinancialAccountingModule["queries"];

export interface DefineModuleParams<
  BaF extends Record<string, TailorAnyDBField> = EmptyFields,
  BsF extends Record<string, TailorAnyDBField> = EmptyFields,
  BslF extends Record<string, TailorAnyDBField> = EmptyFields,
> {
  bankAccount?: CreateBankAccountTypeParams<BaF>;
  bankStatement?: CreateBankStatementTypeParams<BsF>;
  bankStatementLine?: CreateBankStatementLineTypeParams<BslF>;
  organization: {
    db: { company: OrganizationDB["company"] };
    queries: Pick<OrganizationQueries, "getCompany">;
  };
  primitives: {
    db: { currency: PrimitivesDB["currency"] };
    queries: Pick<PrimitivesQueries, "getCurrency">;
  };
  coaManagement: {
    db: { account: CoaManagementDB["account"] };
    queries: Pick<CoaManagementQueries, "getAccount">;
  };
  accountReceivable: {
    queries: Pick<AccountReceivableQueries, "getIncomingPayment">;
  };
  accountPayable: {
    queries: Pick<AccountPayableQueries, "getOutgoingPayment">;
  };
  financialAccounting: {
    commands: Pick<
      FinancialAccountingCommands,
      "createJournalEntry" | "postJournalEntry" | "reverseJournalEntry"
    >;
    queries: Pick<FinancialAccountingQueries, "getPeriodByDate" | "getJournalEntryBySource">;
  };
}

/* @__NO_SIDE_EFFECTS__ */
export const defineModule = <
  const BaF extends Record<string, TailorAnyDBField> = EmptyFields,
  const BsF extends Record<string, TailorAnyDBField> = EmptyFields,
  const BslF extends Record<string, TailorAnyDBField> = EmptyFields,
>(
  params: DefineModuleParams<BaF, BsF, BslF>,
) => {
  const bankAccount = createBankAccountType({
    ...params.bankAccount,
    companyType: params.organization.db.company,
    currencyType: params.primitives.db.currency,
    accountType: params.coaManagement.db.account,
  });
  const bankStatement = createBankStatementType({ ...params.bankStatement });
  const bankReconciliation = createBankReconciliationType();
  const bankStatementLine = createBankStatementLineType({
    ...params.bankStatementLine,
    bankReconciliationType: bankReconciliation,
  });
  const bankReconciliationItem = createBankReconciliationItemType();

  return {
    db: {
      bankAccount,
      bankStatement,
      bankStatementLine,
      bankReconciliation,
      bankReconciliationItem,
    },
    commands: {
      createBankAccount: createBankAccount<TailorDBInsertable<BaF>>(
        params.organization.queries,
        params.primitives.queries,
        params.coaManagement.queries,
      ),
      createBankStatement: createBankStatement<TailorDBInsertable<BsF>, TailorDBInsertable<BslF>>(),
      reconcileBankTransactions: reconcileBankTransactions(
        params.accountReceivable.queries,
        params.accountPayable.queries,
        params.financialAccounting.commands,
        params.financialAccounting.queries,
      ),
      reverseBankReconciliation: reverseBankReconciliation(
        params.financialAccounting.commands,
        params.financialAccounting.queries,
      ),
    },
    queries: {},
  };
};

export type CashManagementModule = ReturnType<
  typeof defineModule<EmptyFields, EmptyFields, EmptyFields>
>;