import type { Category } from './api';

export type ItemStatus = 'pending' | 'available' | 'reserved' | 'sold';

export interface ItemFilters {
  categoryId: number | null;
  tagIds: number[];
  minPriceCents: number | null;
  maxPriceCents: number | null;
  // Several statuses, because the control this serves is not a status filter:
  // "Not Sold" is available-or-reserved on the storefront and includes pending
  // in the admin, neither of which is one value.
  //
  // Null means "no preference", which each side turns into its own default -
  // Not Sold on the storefront, every status in the admin. Keeping the default
  // as null rather than as an explicit list is what keeps it out of the URL and
  // out of the active-filter count.
  status: ItemStatus[] | null;
  // Storefront only, and only meaningful when signed in. Sold favorites are
  // included: the storefront shows sold items everywhere else, and a favorite
  // that has just sold is often exactly what the customer came to look at.
  favoritesOnly: boolean;
}

// The three-way control both screens offer. It is a preset over the status
// list rather than a filter of its own, so there is only ever one dimension and
// no way to express a contradiction like "sold and not sold".
export type SaleState = 'sold' | 'not-sold' | 'all';

// The same three words mean different sets in the two places, which is worth
// stating twice rather than sharing one table that would be wrong for one of
// them. Pending is excluded from every public read regardless of filter, so on
// the storefront "All" cannot and must not include it — a label promising more
// than it delivers.
export const STOREFRONT_SALE_STATUSES: Record<SaleState, ItemStatus[]> = {
  'not-sold': ['available', 'reserved'],
  sold: ['sold'],
  all: ['available', 'reserved', 'sold']
};

// In the admin, Not Sold includes pending: an item awaiting publication has
// certainly not been sold, and hiding it from the default view would hide the
// items most likely to need attention.
export const ADMIN_SALE_STATUSES: Record<SaleState, ItemStatus[]> = {
  'not-sold': ['available', 'reserved', 'pending'],
  sold: ['sold'],
  all: ['available', 'reserved', 'sold', 'pending']
};

function isPublicStatus(value: string): value is ItemStatus {
  return value === 'available' || value === 'reserved' || value === 'sold';
}

const sameSet = (a: readonly string[], b: readonly string[]) =>
  a.length === b.length && [...a].sort().join() === [...b].sort().join();

// Which preset a status list corresponds to, for showing the control's current
// position. Null means no preference, which each screen renders as its default.
// A list matching none of the three - only reachable by hand-editing the URL -
// reports as the default rather than leaving the control blank.
export function saleStateFromStatuses(
  statuses: ItemStatus[] | null,
  table: Record<SaleState, ItemStatus[]>,
  fallback: SaleState = 'not-sold'
): SaleState {
  if (statuses === null) return fallback;
  const match = (Object.keys(table) as SaleState[]).find((state) =>
    sameSet(statuses, table[state])
  );
  return match ?? fallback;
}

export const EMPTY_FILTERS: ItemFilters = {
  categoryId: null,
  tagIds: [],
  minPriceCents: null,
  maxPriceCents: null,
  status: null,
  favoritesOnly: false
};

// Filters live in the URL so a filtered view can be linked, bookmarked, and
// walked back through with the browser's back button. The param names match
// what GET /api/items accepts, so the same object serializes for both.
export function filtersToSearchParams(filters: ItemFilters): URLSearchParams {
  const params = new URLSearchParams();
  if (filters.categoryId !== null) params.set('category', String(filters.categoryId));
  if (filters.tagIds.length) params.set('tags', filters.tagIds.join(','));
  if (filters.minPriceCents !== null) params.set('min_price', String(filters.minPriceCents));
  if (filters.maxPriceCents !== null) params.set('max_price', String(filters.maxPriceCents));
  if (filters.status !== null) params.set('status', filters.status.join(','));
  if (filters.favoritesOnly) params.set('favorites', '1');
  return params;
}

function readInt(raw: string | null): number | null {
  if (raw === null || raw.trim() === '') return null;
  const parsed = Number(raw);
  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
}

export function filtersFromSearchParams(params: URLSearchParams): ItemFilters {
  const tags = (params.get('tags') || '')
    .split(',')
    .map((part) => readInt(part))
    .filter((id): id is number => id !== null && id > 0);

  // Deliberately does NOT accept 'pending', even though it is a valid
  // ItemStatus. This reader exists for the storefront's URL, where filtering by
  // pending is not a thing a customer may ask for — the public API refuses it
  // outright, so parsing it here would only produce a request guaranteed to
  // fail. The admin's status filter holds its value in React state and never
  // round-trips through this function, so it is unaffected. Do not "complete"
  // this list to match the type.
  //
  // A list containing anything unreadable yields null - the default - rather
  // than the readable subset, so a mangled link falls back to a view that is
  // explainable instead of one silently narrower than it looks.
  const rawStatus = params.get('status');
  const parsedStatus = (rawStatus || '')
    .split(',')
    .map((part) => part.trim())
    .filter((part) => part !== '');
  const status =
    parsedStatus.length > 0 && parsedStatus.every(isPublicStatus)
      ? (parsedStatus as ItemStatus[])
      : null;

  const favorites = params.get('favorites');

  return {
    categoryId: readInt(params.get('category')),
    tagIds: tags,
    minPriceCents: readInt(params.get('min_price')),
    maxPriceCents: readInt(params.get('max_price')),
    status,
    favoritesOnly: favorites === '1' || favorites === 'true'
  };
}

// One count for the "Filters (N)" button. A price range counts once however
// many ends are set, since it reads as a single filter to the user.
//
// Status is deliberately not counted. It has its own always-visible control
// beside this button rather than living in the drawer, so counting it would put
// a number on a button whose drawer shows nothing set — and the control already
// displays its own position.
export function activeFilterCount(filters: ItemFilters): number {
  let count = 0;
  if (filters.categoryId !== null) count++;
  count += filters.tagIds.length;
  if (filters.minPriceCents !== null || filters.maxPriceCents !== null) count++;
  if (filters.favoritesOnly) count++;
  return count;
}

// Broader than the count above, and intentionally so: this decides whether an
// empty result reads as "no items match these filters" with a way out, or as an
// empty shop. A status filter that matched nothing is exactly the case where
// that distinction matters, so it counts here even though it is not in the
// drawer's tally.
export function hasActiveFilters(filters: ItemFilters): boolean {
  return activeFilterCount(filters) > 0 || filters.status !== null;
}

export interface CategoryNode extends Category {
  children: CategoryNode[];
}

// The API returns categories flat; the tree is rebuilt here so the drawer and
// the admin tab share one nesting implementation.
export function buildCategoryTree(categories: Category[]): CategoryNode[] {
  const byId = new Map<number, CategoryNode>();
  for (const category of categories) {
    byId.set(category.id, { ...category, children: [] });
  }

  const roots: CategoryNode[] = [];
  for (const node of byId.values()) {
    const parent = node.parent_id === null ? undefined : byId.get(node.parent_id);
    // A node whose parent is missing is treated as a root rather than dropped,
    // so nothing can silently disappear from the tree.
    if (parent) {
      parent.children.push(node);
    } else {
      roots.push(node);
    }
  }
  return roots;
}

// "Furniture / Tables / Coffee Tables" — used on chips and in the admin form so
// a leaf name like "Vintage" isn't ambiguous between branches.
export function categoryPath(categories: Category[], id: number): string {
  const byId = new Map(categories.map((category) => [category.id, category]));
  const parts: string[] = [];
  let current = byId.get(id);
  while (current) {
    parts.unshift(current.name);
    current = current.parent_id === null ? undefined : byId.get(current.parent_id);
    // Guards against a cycle that somehow reached the client.
    if (parts.length > 32) break;
  }
  return parts.join(' / ');
}

export function formatPriceRange(minCents: number | null, maxCents: number | null): string {
  const dollars = (cents: number) => `$${(cents / 100).toFixed(0)}`;
  if (minCents !== null && maxCents !== null) return `${dollars(minCents)}–${dollars(maxCents)}`;
  if (minCents !== null) return `${dollars(minCents)}+`;
  if (maxCents !== null) return `Up to ${dollars(maxCents)}`;
  return '';
}