import { createContext, DomainError } from "@tailor-platform/erp-kit/app";
import { createResolver, t } from "@tailor-platform/sdk";
import { getDB } from "@/generated/kysely-tailordb";
import { bpModulesExport } from "@/modules";
import { assertEnum } from "@/resolver/util/assert-enum";
export default createResolver({
  name: "updateCustomerAccount",
  operation: "mutation",
  input: {
    id: t.string().description("id"),
    name: t.string({ optional: true }).description("name"),
    preferredCurrencyId: t.string({ optional: true }).description("preferredCurrencyId"),
    addAddressUsages: t.object(
      {
        addressId: t.string(),
        purpose: t.string(),
        isDefault: t.bool({ optional: true }),
      },
      { array: true, optional: true },
    ),
    updateAddressUsages: t.object(
      {
        usageId: t.string(),
        isDefault: t.bool(),
      },
      { array: true, optional: true },
    ),
    removeAddressUsageIds: t.string({ array: true, optional: true }),
    addBankAccountUsages: t.object(
      {
        bankAccountId: t.string(),
        purpose: t.string(),
        isDefault: t.bool({ optional: true }),
      },
      { array: true, optional: true },
    ),
    updateBankAccountUsages: t.object(
      {
        usageId: t.string(),
        isDefault: t.bool(),
      },
      { array: true, optional: true },
    ),
    removeBankAccountUsageIds: t.string({ array: true, optional: true }),
  },
  body: async (context) => {
    const ctx = createContext(context);

    return getDB("main-db")
      .transaction()
      .execute(async (trx) => {
        const result = await bpModulesExport.commands.updateCustomerAccount(
          trx,
          {
            id: context.input.id,
            headerPatch: {
              name:
                context.input.name === undefined ? undefined : (context.input.name?.trim() ?? ""),
              preferredCurrencyId:
                context.input.preferredCurrencyId === undefined
                  ? undefined
                  : context.input.preferredCurrencyId || null,
            },
            addAddressUsages: context.input.addAddressUsages?.map((usage) => ({
              addressId: usage.addressId,
              purpose: assertEnum(usage.purpose, ["BILL_TO", "SHIP_TO"] as const, "purpose"),
              isDefault: usage.isDefault ?? false,
            })),
            updateAddressUsages: context.input.updateAddressUsages?.map((usage) => ({
              usageId: usage.usageId,
              usagePatch: { isDefault: usage.isDefault },
            })),
            removeAddressUsageIds: context.input.removeAddressUsageIds ?? undefined,
            addBankAccountUsages: context.input.addBankAccountUsages?.map((usage) => ({
              bankAccountId: usage.bankAccountId,
              purpose: assertEnum(usage.purpose, ["RECEIPT", "REFUND"] as const, "purpose"),
              isDefault: usage.isDefault ?? false,
            })),
            updateBankAccountUsages: context.input.updateBankAccountUsages?.map((usage) => ({
              usageId: usage.usageId,
              usagePatch: { isDefault: usage.isDefault },
            })),
            removeBankAccountUsageIds: context.input.removeBankAccountUsageIds ?? undefined,
          },
          ctx,
        );
        if (!result.ok) {
          switch (result.error.code) {
            case "UNAUTHENTICATED":
              throw new DomainError("Authentication is required");
            case "INSUFFICIENT_PERMISSION":
              throw new DomainError("You do not have permission to perform this action");
            default:
              throw new DomainError(result.error.message);
          }
        }
        return { id: result.value.customerAccountId };
      });
  },
  output: t.object({ id: t.string().description("ID") }),
});