// src/features/admin-purchases-orders/PurchasesOrders.tsx
// Admin: purchases / transactions list — /admin/purchases/orders

'use client';

import { useT, useLocale } from '@/lib/i18n/react';
import { interpolate } from '@/lib/i18n/interpolate';
import { ErrorBoundary } from '@/components/ui/feedback/ErrorBoundary';
import { ErrorState } from '@/components/ui/feedback/ErrorState';
import { AdminListPageSkeleton } from '@/components/ui/feedback/Skeleton';
import { usePaginatedQuery } from '@/lib/hooks/usePaginatedQuery';
import { AdminListPage } from '@/components/ui/domain/admin/AdminListPage';
import { AdminTable, type ColumnDef } from '@/components/ui/domain/admin/AdminTable';
import { AdminFilterBar, type FilterChip } from '@/components/ui/domain/admin/AdminFilterBar';
import { Pagination } from '@/components/ui/primitives/Pagination';
import { useAdminFilters } from '@/components/ui/domain/admin/AdminFilterBar/useAdminFilters';
import { StatusBadge, type StatusEntry } from '@/components/ui/domain/StatusBadge/StatusBadge';
import {
  Tooltip,
  TooltipContent,
  TooltipProvider,
  TooltipTrigger,
} from '@/components/ui/overlays/Tooltip';
import { Button } from '@/components/ui/primitives/Button';
import { formatDate } from '@/lib/format';
import { formatShekelFloat } from '@/lib/money';
import { PAYMENT_STATUS } from '@/lib/enums/payment-status';
import { QueryBoundary } from '@platform-modules/ui-primitives';

export interface PurchaseRow {
  id: string;
  dealTitle: string;
  vendorName: string;
  customerDisplayName: string | null;
  amountPaid: string;
  commissionAmount: string;
  vendorAmount: string;
  paymentStatus: string;
  redemptionStatus: string;
  dealId: string;
  vendorId: string;
  createdAt: string;
  redeemedAt: string | null;
  cancelledAt: string | null;
  expiresAt: string;
}

export interface PurchasesOrdersProps {
  initialPurchases: PurchaseRow[];
  initialTotal: number;
  initialPage?: number;
}

export const PAYMENT_STATUS_MAP: Record<string, StatusEntry> = {
  COMPLETED: { tone: 'success', labelKey: 'payment_completed' },
  PENDING: { tone: 'warning', labelKey: 'payment_pending' },
  REFUND_REQUESTED: { tone: 'warning', labelKey: 'payment_refund_requested' },
  REFUNDED: { tone: 'neutral', labelKey: 'payment_refunded' },
  PARTIAL_REFUND: { tone: 'neutral', labelKey: 'payment_partial_refund' },
};

export const REDEMPTION_STATUS_MAP: Record<string, StatusEntry> = {
  REDEEMED: { tone: 'success', labelKey: 'redemption_redeemed' },
  UNREDEEMED: { tone: 'info', labelKey: 'redemption_unredeemed' },
  CANCELLED: { tone: 'danger', labelKey: 'redemption_cancelled' },
  EXPIRED: { tone: 'neutral', labelKey: 'redemption_expired' },
};

const FILTER_KEYS = ['paymentStatus', 'redemptionStatus', 'from', 'to', 'vendorId'];
const PAGE_LIMIT = 20;

const PAYMENT_TOOLTIP_KEYS: Record<string, string> = {
  COMPLETED: 'tooltip_payment_completed',
  PENDING: 'tooltip_payment_pending',
  REFUND_REQUESTED: 'tooltip_payment_refund_requested',
  REFUNDED: 'tooltip_payment_refunded',
  PARTIAL_REFUND: 'tooltip_payment_partial_refund',
};

const REDEMPTION_TOOLTIP_KEYS: Record<string, string> = {
  REDEEMED: 'tooltip_redemption_redeemed',
  UNREDEEMED: 'tooltip_redemption_unredeemed',
  CANCELLED: 'tooltip_redemption_cancelled',
  EXPIRED: 'tooltip_redemption_expired',
};

function StatusBadgeWithTooltip({
  state,
  map,
  tooltipKey,
}: {
  state: string;
  map: Record<string, StatusEntry>;
  tooltipKey?: string;
}) {
  const t = useT('admin_purchases');
  const badge = <StatusBadge state={state} map={map} ns="admin_purchases" size="sm" />;
  if (!tooltipKey) return badge;
  return (
    <Tooltip>
      <TooltipTrigger asChild>
        <span className="inline-flex">{badge}</span>
      </TooltipTrigger>
      <TooltipContent side="top" className="max-w-xs text-wrap">
        {t(tooltipKey as never)}
      </TooltipContent>
    </Tooltip>
  );
}

export function PurchasesOrders({
  initialPurchases,
  initialTotal,
  initialPage,
}: PurchasesOrdersProps) {
  const t = useT('admin_purchases');
  const tList = useT('admin_list');
  const { locale } = useLocale();
  const { filters } = useAdminFilters(FILTER_KEYS);

  const params: Record<string, string> = {};
  if (filters['paymentStatus']) params.paymentStatus = filters['paymentStatus'];
  if (filters['redemptionStatus']) params.redemptionStatus = filters['redemptionStatus'];
  if (filters['from']) params.from = filters['from'];
  if (filters['to']) params.to = filters['to'];
  if (filters['vendorId']) params.vendorId = filters['vendorId'];

  const hasActiveFilters = Boolean(
    filters['paymentStatus'] ||
    filters['redemptionStatus'] ||
    filters['from'] ||
    filters['to'] ||
    filters['vendorId'],
  );

  const {
    data,
    total,
    totalPages,
    page,
    isLoading,
    isInitialLoading,
    isRefetching,
    error,
    setPage,
    refetch,
  } = usePaginatedQuery<PurchaseRow>({
    endpoint: '/api/admin/purchases',
    params,
    limit: PAGE_LIMIT,
    initialData: initialPurchases,
    initialTotal,
    initialPage,
    dataKey: 'purchases',
  });

  const paymentChips: FilterChip[] = PAYMENT_STATUS.map((status) => ({
    key: 'paymentStatus',
    value: status,
    label: t(`payment_${status.toLowerCase()}` as Parameters<typeof t>[0]),
    groupLabel: `${t('filter_payment_status')}:`,
  }));

  const redemptionChips: FilterChip[] = [
    {
      key: 'redemptionStatus',
      value: 'UNREDEEMED',
      label: t('redemption_unredeemed'),
      groupLabel: `${t('filter_redemption_status')}:`,
    },
    {
      key: 'redemptionStatus',
      value: 'REDEEMED',
      label: t('redemption_redeemed'),
      groupLabel: `${t('filter_redemption_status')}:`,
    },
    {
      key: 'redemptionStatus',
      value: 'EXPIRED',
      label: t('redemption_expired'),
      groupLabel: `${t('filter_redemption_status')}:`,
    },
    {
      key: 'redemptionStatus',
      value: 'CANCELLED',
      label: t('redemption_cancelled'),
      groupLabel: `${t('filter_redemption_status')}:`,
    },
  ];

  const columns: ColumnDef<PurchaseRow>[] = [
    {
      key: 'createdAt',
      label: t('col_date'),
      render: (r) => formatDate(r.createdAt, locale),
    },
    {
      key: 'customerDisplayName',
      label: t('col_customer'),
      render: (r) => (
        <span className="text-text-primary font-medium" data-diag="" data-user-displayname>
          {r.customerDisplayName || t('col_customer_guest')}
        </span>
      ),
    },
    {
      key: 'vendorName',
      label: t('col_vendor'),
      render: (r) => (
        <span className="text-text-secondary" data-user-displayname>
          {r.vendorName}
        </span>
      ),
    },
    {
      key: 'dealTitle',
      label: t('col_deal'),
      render: (r) => (
        <span className="text-text-primary font-medium" data-diag="" data-user-displayname>
          {r.dealTitle}
        </span>
      ),
    },
    {
      key: 'amountPaid',
      label: t('col_amount'),
      align: 'end',
      headerTooltip: t('tooltip_col_amount'),
      render: (r) => <span className="font-medium">{formatShekelFloat(r.amountPaid)}</span>,
    },
    {
      key: 'paymentStatus',
      label: t('col_payment_status'),
      render: (r) => (
        <StatusBadgeWithTooltip
          state={r.paymentStatus}
          map={PAYMENT_STATUS_MAP}
          tooltipKey={PAYMENT_TOOLTIP_KEYS[r.paymentStatus]}
        />
      ),
    },
    {
      key: 'redemptionStatus',
      label: t('col_redemption_status'),
      render: (r) => (
        <StatusBadgeWithTooltip
          state={r.redemptionStatus}
          map={REDEMPTION_STATUS_MAP}
          tooltipKey={REDEMPTION_TOOLTIP_KEYS[r.redemptionStatus]}
        />
      ),
    },
  ];

  const rangeFrom = total > 0 ? (page - 1) * PAGE_LIMIT + 1 : 0;
  const rangeTo = Math.min(page * PAGE_LIMIT, total);
  const rangeLabel =
    total > 0
      ? interpolate(tList('showing_x_of_y'), { from: rangeFrom, to: rangeTo, total })
      : null;

  const purchasesQuery = {
    data: isInitialLoading ? undefined : { rows: data, totalPages, page },
    isLoading: isInitialLoading,
    isPending: isInitialLoading,
    isError: Boolean(error),
    error: error ? new Error(error) : null,
    refetch,
  };

  return (
    <ErrorBoundary>
      <TooltipProvider delayDuration={200}>
        <QueryBoundary
          query={purchasesQuery}
          skeleton={<AdminListPageSkeleton tableCols={7} />}
          errorFallback={() => (
            <ErrorState
              title={tList('error_title')}
              description={tList('error_desc')}
              action={
                <Button variant="secondary" size="sm" onClick={() => refetch()}>
                  {tList('retry')}
                </Button>
              }
            />
          )}
        >
          {(resolved) => {
            const data = resolved.rows;

            return (
              <AdminListPage
                busy={isRefetching}
                filterBar={
                  <div className="flex flex-col gap-2">
                    <AdminFilterBar
                      chips={[...paymentChips, ...redemptionChips]}
                      dateRange={{
                        fromKey: 'from',
                        toKey: 'to',
                        fromLabel: t('date_from'),
                        toLabel: t('date_to'),
                      }}
                    />
                    {rangeLabel ? (
                      <p className="text-text-secondary text-xs" aria-live="polite">
                        {rangeLabel}
                      </p>
                    ) : null}
                  </div>
                }
                table={
                  <AdminTable<PurchaseRow>
                    columns={columns}
                    rows={data}
                    virtualize={{
                      estimateRowHeight: 56,
                      scrollRestorationKey: '/admin/purchases/orders',
                      scrollRestorationReady: !isLoading && data.length > 0,
                    }}
                    rowHref={(r) => `/admin/purchases/${r.id}`}
                    emptyTitle={
                      hasActiveFilters ? t('no_results_filtered') : t('no_results_unfiltered')
                    }
                    emptyDesc={hasActiveFilters ? undefined : t('no_results')}
                  />
                }
                pagination={
                  resolved.totalPages > 1 ? (
                    <Pagination
                      page={resolved.page}
                      totalPages={resolved.totalPages}
                      onPageChange={setPage}
                    />
                  ) : undefined
                }
              />
            );
          }}
        </QueryBoundary>
      </TooltipProvider>
    </ErrorBoundary>
  );
}

/** @deprecated Use PurchasesOrders */
export const PurchasesMgmt = PurchasesOrders;
export type PurchasesMgmtProps = PurchasesOrdersProps;