import { ok } from "@tailor-platform/erp-kit/core";
import { vi } from "vitest";
import type {
  BusinessPartnerQueries,
  CoaManagementQueries,
  FinancialAccountingCommands,
  FinancialAccountingQueries,
  InventoryCommands,
  InventoryQueries,
  OrganizationQueries,
  PrimitivesQueries,
  PurchaseCommands,
  PurchaseQueries,
} from "../module";

export type Company = NonNullable<
  Awaited<ReturnType<OrganizationQueries["getCompany"]>>["value"]["company"]
>;
export type SupplierAccountReference = NonNullable<
  Awaited<ReturnType<BusinessPartnerQueries["getSupplierAccount"]>>["value"]["account"]
>;
export type Currency = NonNullable<
  Awaited<ReturnType<PrimitivesQueries["getCurrency"]>>["value"]["currency"]
>;
export type Account = NonNullable<
  Awaited<ReturnType<CoaManagementQueries["getAccount"]>>["value"]["account"]
>;
export type PurchaseOrderLineForMatching = Awaited<
  ReturnType<PurchaseQueries["listPurchaseOrderLinesForMatching"]>
>["value"]["purchaseOrderLines"][number];
export type ItemValuationPolicyResolution = Awaited<
  ReturnType<InventoryQueries["resolveItemValuationPolicies"]>
>["value"]["resolutions"][number];
export type ValuationPolicy = ItemValuationPolicyResolution["valuationPolicy"];

export const mockOrganizationQueries = (store: { companies?: Company[] }) => ({
  getCompany: vi.fn<OrganizationQueries["getCompany"]>((_db, input) =>
    Promise.resolve(
      ok({ company: store.companies?.find((company) => company.id === input.id) ?? null }),
    ),
  ),
});

export const mockSupplierAccountQueries = (store: {
  supplierAccounts?: SupplierAccountReference[];
}) => ({
  getSupplierAccount: vi.fn<BusinessPartnerQueries["getSupplierAccount"]>((_db, input) =>
    Promise.resolve(
      ok({
        account:
          store.supplierAccounts?.find((account) => account.id === input.supplierAccountId) ?? null,
      }),
    ),
  ),
});

export const mockPrimitivesQueries = (store: { currencies?: Currency[] }) => ({
  getCurrency: vi.fn<PrimitivesQueries["getCurrency"]>((_db, input) =>
    Promise.resolve(
      ok({
        currency:
          ("id" in input
            ? store.currencies?.find((currency) => currency.id === input.id)
            : store.currencies?.find((currency) => currency.code === input.code)) ?? null,
      }),
    ),
  ),
});

export const mockCoaManagementQueries = (store: { accounts?: Account[] }) => ({
  getAccount: vi.fn<CoaManagementQueries["getAccount"]>((_db, input) =>
    Promise.resolve(
      ok({
        account:
          ("id" in input
            ? store.accounts?.find((account) => account.id === input.id)
            : store.accounts?.find(
                (account) => account.companyId === input.companyId && account.code === input.code,
              )) ?? null,
      }),
    ),
  ),
  listAccounts: vi.fn<CoaManagementQueries["listAccounts"]>((_db, input) =>
    Promise.resolve(
      ok({
        items: (store.accounts ?? []).filter(
          (account) =>
            account.companyId === input.companyId &&
            (!input.accountIds || input.accountIds.includes(account.id)) &&
            (!input.accountType || account.accountType === input.accountType) &&
            (!input.status || account.status === input.status),
        ),
        hasNextPage: false,
      }),
    ),
  ),
});

export const mockPurchaseQueries = (store: {
  purchaseOrderLines?: PurchaseOrderLineForMatching[];
}) => ({
  listPurchaseOrderLinesForMatching: vi.fn<PurchaseQueries["listPurchaseOrderLinesForMatching"]>(
    (_db, input) =>
      Promise.resolve(
        ok({
          purchaseOrderLines: (store.purchaseOrderLines ?? []).filter((line) =>
            input.purchaseOrderLineIds.includes(line.id),
          ),
        }),
      ),
  ),
});

export const mockInventoryQueries = (store: {
  itemValuationPolicies?: ItemValuationPolicyResolution[];
}) => ({
  resolveItemValuationPolicies: vi.fn<InventoryQueries["resolveItemValuationPolicies"]>(
    (_db, input) =>
      Promise.resolve(
        ok({
          // The real query omits an item it cannot resolve, so an item absent
          // from the store stands in for one no policy governs.
          resolutions: (store.itemValuationPolicies ?? []).filter((resolution) =>
            input.itemIds.includes(resolution.itemId),
          ),
        }),
      ),
  ),
});

export const mockPurchaseCommands = () => ({
  recalculatePurchaseOrderBillingStatus: vi.fn<
    PurchaseCommands["recalculatePurchaseOrderBillingStatus"]
  >(() => Promise.resolve(ok({ purchaseOrderIds: [] }))),
});

const journalEntry = {
  id: "journal-entry-1",
  companyId: "company-1",
  accountingPeriodId: "accounting-period-1",
  entryDate: new Date("2024-01-15"),
  status: "POSTED",
  description: "INVOICE AP-10000001",
  sourceDocumentType: "ACCOUNT_PAYABLE_DOCUMENT",
  sourceDocumentId: "ap-document-1",
  reversalOfId: null,
  postedAt: new Date("2024-01-15"),
  createdAt: new Date("2024-01-15"),
  updatedAt: new Date("2024-01-15"),
};

export const mockFinancialAccountingCommands = () => ({
  createJournalEntry: vi.fn(() => Promise.resolve(ok({ journalEntry }))) as unknown as ReturnType<
    typeof vi.fn<FinancialAccountingCommands["createJournalEntry"]>
  >,
  postJournalEntry: vi.fn(() => Promise.resolve(ok({ journalEntry }))) as unknown as ReturnType<
    typeof vi.fn<FinancialAccountingCommands["postJournalEntry"]>
  >,
});

export const mockInventoryCommands = () => ({
  postAcquisitionCostAdjustment: vi.fn(() =>
    Promise.resolve(ok({ acquisitionCostAdjustments: [] })),
  ) as unknown as ReturnType<typeof vi.fn<InventoryCommands["postAcquisitionCostAdjustment"]>>,
});

export const mockFinancialAccountingQueries = (accountingPeriod: object | null = {}) => ({
  getPeriodByDate: vi.fn(() =>
    Promise.resolve(
      ok({
        accountingPeriod:
          accountingPeriod === null
            ? null
            : {
                id: "accounting-period-1",
                companyId: "company-1",
                fiscalYearId: "fiscal-year-1",
                name: "January 2024",
                startDate: new Date("2024-01-01"),
                endDate: new Date("2024-01-31"),
                periodType: "OPERATING",
                status: "OPEN",
                createdAt: new Date("2024-01-01"),
                updatedAt: new Date("2024-01-01"),
                ...accountingPeriod,
              },
      }),
    ),
  ) as unknown as ReturnType<typeof vi.fn<FinancialAccountingQueries["getPeriodByDate"]>>,
});