kandev/apps/web/lib/sidebar/apply-view.ts

import { classifyTask, type TaskBucket } from "@/components/task/task-classify";
import type { TaskSwitcherItem } from "@/components/task/task-switcher";
import { getExecutorLabel } from "@/lib/executor-icons";
import { formatTaskStateLabel } from "@/lib/ui/state-labels";
import type {
  FilterClause,
  FilterDimension,
  FilterOp,
  FilterValue,
  GroupKey,
  SidebarView,
  SortKey,
  SortSpec,
} from "@/lib/state/slices/ui/sidebar-view-types";

export type SidebarGroup = {
  key: string;
  label: string;
  tasks: TaskSwitcherItem[];
};

export type GroupedSidebarList = {
  groups: SidebarGroup[];
  subTasksByParentId: Map<string, TaskSwitcherItem[]>;
};

export type SidebarTaskPrefs = {
  pinnedTaskIds: string[];
  orderedTaskIds: string[];
  subtaskOrderByParentId?: Record<string, string[]>;
};

type DimensionExtractor = (task: TaskSwitcherItem) => FilterValue | undefined;

const STATE_BUCKET_ORDER: Record<TaskBucket, number> = {
  review: 0,
  in_progress: 1,
  backlog: 2,
};

function getStateBucket(task: TaskSwitcherItem): TaskBucket {
  return classifyTask(task.sessionState, task.state);
}

const dimensionExtractors: Record<FilterDimension, DimensionExtractor> = {
  archived: (t) => t.isArchived === true,
  // State filters intentionally use the action buckets exposed by the filter UI.
  state: (t) => getStateBucket(t),
  workflow: (t) => t.workflowId,
  workflowStep: (t) => t.workflowStepId,
  executorType: (t) => t.remoteExecutorType,
  repository: (t) => (t.repositories && t.repositories.length > 1 ? "__multi__" : t.repositoryPath),
  hasDiff: (t) => {
    const ds = t.diffStats;
    return !!ds && (ds.additions > 0 || ds.deletions > 0);
  },
  hasPR: (t) => !!t.prInfo,
  isPRReview: (t) => t.isPRReview === true,
  isIssueWatch: (t) => t.isIssueWatch === true,
  titleMatch: (t) => t.title ?? "",
};

function toStringArray(v: FilterValue): string[] {
  if (Array.isArray(v)) return v.map(String);
  return [String(v)];
}

function evaluateClause(task: TaskSwitcherItem, clause: FilterClause): boolean {
  const extract = dimensionExtractors[clause.dimension];
  const actual = extract(task);

  switch (clause.op) {
    case "is":
      return String(actual) === String(clause.value);
    case "is_not":
      return String(actual) !== String(clause.value);
    case "in":
      return toStringArray(clause.value).includes(String(actual));
    case "not_in":
      return !toStringArray(clause.value).includes(String(actual));
    case "matches": {
      const hay = String(actual ?? "").toLowerCase();
      const needle = String(clause.value).toLowerCase();
      return needle === "" || hay.includes(needle);
    }
    case "not_matches": {
      const hay = String(actual ?? "").toLowerCase();
      const needle = String(clause.value).toLowerCase();
      return needle !== "" && !hay.includes(needle);
    }
    default:
      return true;
  }
}

export function applyFilters(
  tasks: TaskSwitcherItem[],
  clauses: FilterClause[],
): TaskSwitcherItem[] {
  if (clauses.length === 0) return tasks;
  return tasks.filter((task) => clauses.every((clause) => evaluateClause(task, clause)));
}

type SortComparator = (a: TaskSwitcherItem, b: TaskSwitcherItem) => number;

const SORT_COMPARATORS: Record<Exclude<SortKey, "custom">, SortComparator> = {
  state: (a, b) => {
    const bucket = STATE_BUCKET_ORDER[getStateBucket(a)] - STATE_BUCKET_ORDER[getStateBucket(b)];
    if (bucket !== 0) return bucket;
    // Tiebreak: newest createdAt first (preserves historical sidebar ordering)
    return (b.createdAt ?? "").localeCompare(a.createdAt ?? "");
  },
  updatedAt: (a, b) => (a.updatedAt ?? "").localeCompare(b.updatedAt ?? ""),
  createdAt: (a, b) => (a.createdAt ?? "").localeCompare(b.createdAt ?? ""),
  title: (a, b) => (a.title ?? "").localeCompare(b.title ?? ""),
};

function customComparator(orderedTaskIds: string[]): SortComparator {
  const order = new Map<string, number>();
  for (let i = 0; i < orderedTaskIds.length; i++) order.set(orderedTaskIds[i], i);
  return (a, b) => {
    const ai = order.get(a.id);
    const bi = order.get(b.id);
    if (ai !== undefined && bi !== undefined) return ai - bi;
    if (ai !== undefined) return -1;
    if (bi !== undefined) return 1;
    // Fallback for tasks the user hasn't placed yet: newest createdAt first.
    return (b.createdAt ?? "").localeCompare(a.createdAt ?? "");
  };
}

export function applySort(
  tasks: TaskSwitcherItem[],
  spec: SortSpec,
  orderedTaskIds: string[] = [],
  subTasksByParentId?: Map<string, TaskSwitcherItem[]>,
): TaskSwitcherItem[] {
  let cmp: SortComparator;
  if (spec.key === "state" && subTasksByParentId) {
    const effectiveOrder = new Map<string, number>();
    for (const t of tasks) {
      let order = STATE_BUCKET_ORDER[getStateBucket(t)];
      const subs = subTasksByParentId.get(t.id);
      if (subs) {
        for (const sub of subs) {
          order = Math.min(order, STATE_BUCKET_ORDER[getStateBucket(sub)]);
        }
      }
      effectiveOrder.set(t.id, order);
    }
    cmp = (a, b) => {
      const bucket = effectiveOrder.get(a.id)! - effectiveOrder.get(b.id)!;
      if (bucket !== 0) return bucket;
      return (b.createdAt ?? "").localeCompare(a.createdAt ?? "");
    };
  } else {
    cmp = spec.key === "custom" ? customComparator(orderedTaskIds) : SORT_COMPARATORS[spec.key];
  }
  // "Custom" is a manual order — reversing it on direction=desc would flip
  // the user's drag, which has no intuitive meaning. The picker hides the
  // direction toggle for custom; this guard keeps the data layer consistent
  // even if a stored view ends up with desc direction.
  const sign = spec.key !== "custom" && spec.direction === "desc" ? -1 : 1;
  const withIndex = tasks.map((t, i) => ({ t, i }));
  withIndex.sort((a, b) => {
    const primary = cmp(a.t, b.t) * sign;
    if (primary !== 0) return primary;
    return a.i - b.i;
  });
  return withIndex.map((x) => x.t);
}

const UNASSIGNED_LABEL = "Unassigned";
const MULTI_REPO_LABEL = "Multi-repo";
const NOT_STARTED_STATE_GROUP_KEY = "__not_started__";

const STATE_GROUP_ORDER: Record<string, number> = {
  [NOT_STARTED_STATE_GROUP_KEY]: 0,
  CREATED: 1,
  SCHEDULING: 2,
  TODO: 3,
  IN_PROGRESS: 4,
  WAITING_FOR_INPUT: 5,
  REVIEW: 6,
  BLOCKED: 7,
  FAILED: 8,
  COMPLETED: 9,
  CANCELLED: 10,
};

type GroupExtractor = (task: TaskSwitcherItem) => { key: string; label: string };

function getTaskStateGroup(task: TaskSwitcherItem): { key: string; label: string } {
  if (!task.state)
    return { key: NOT_STARTED_STATE_GROUP_KEY, label: formatTaskStateLabel(undefined) };
  return { key: task.state, label: formatTaskStateLabel(task.state) };
}

/**
 * Computes the effective state group for a parent task, considering its direct
 * subtasks. The task (or its "best" subtask) with the highest-priority bucket
 * (lowest STATE_BUCKET_ORDER) determines the group. This makes a parent with an
 * active subtask bubble up to the same section as genuinely-running top-level
 * tasks.
 *
 * Tie-break: when multiple candidates share the same bucket, prefer the one
 * with the lowest STATE_GROUP_ORDER (i.e. the earlier/more-active lifecycle
 * state). This is consistent with the existing top-level sort where review
 * (which includes COMPLETED/FAILED/CANCELLED) sorts above in_progress.
 */
function getEffectiveStateGroup(
  task: TaskSwitcherItem,
  subMap: Map<string, TaskSwitcherItem[]>,
): { key: string; label: string } {
  let bestTask = task;
  let bestBucketOrder = STATE_BUCKET_ORDER[getStateBucket(task)];
  let bestStateOrder = STATE_GROUP_ORDER[task.state ?? NOT_STARTED_STATE_GROUP_KEY] ?? 99;

  const subs = subMap.get(task.id);
  if (subs) {
    for (const sub of subs) {
      // Subtasks without an explicit persisted state can't provide a meaningful
      // group heading (getTaskStateGroup would return "not started"), so skip
      // them entirely. The parent still bubbles in applySort via bucket numbers.
      if (!sub.state) continue;
      const subBucketOrder = STATE_BUCKET_ORDER[getStateBucket(sub)];
      if (subBucketOrder < bestBucketOrder) {
        bestTask = sub;
        bestBucketOrder = subBucketOrder;
        bestStateOrder = STATE_GROUP_ORDER[sub.state] ?? 99;
      } else if (subBucketOrder === bestBucketOrder) {
        const subStateOrder = STATE_GROUP_ORDER[sub.state] ?? 99;
        if (subStateOrder < bestStateOrder) {
          bestTask = sub;
          bestStateOrder = subStateOrder;
        }
      }
    }
  }

  return getTaskStateGroup(bestTask);
}

const groupExtractors: Record<Exclude<GroupKey, "none">, GroupExtractor> = {
  repository: (t) => {
    if (t.repositories && t.repositories.length > 1) {
      return { key: "__multi__", label: MULTI_REPO_LABEL };
    }
    if (t.repositoryPath) return { key: t.repositoryPath, label: t.repositoryPath };
    return { key: "__unassigned__", label: UNASSIGNED_LABEL };
  },
  workflow: (t) => {
    if (t.workflowId) return { key: t.workflowId, label: t.workflowName ?? t.workflowId };
    return { key: "__unassigned__", label: UNASSIGNED_LABEL };
  },
  workflowStep: (t) => {
    if (t.workflowStepId) {
      return { key: t.workflowStepId, label: t.workflowStepTitle ?? t.workflowStepId };
    }
    return { key: "__unassigned__", label: UNASSIGNED_LABEL };
  },
  executorType: (t) => {
    if (t.remoteExecutorType) {
      return { key: t.remoteExecutorType, label: getExecutorLabel(t.remoteExecutorType) };
    }
    return { key: "__unassigned__", label: UNASSIGNED_LABEL };
  },
  // State groups use persisted task states so headings match task status labels.
  state: getTaskStateGroup,
};

function separateSubtasks(tasks: TaskSwitcherItem[]): {
  rootTasks: TaskSwitcherItem[];
  subTasksByParentId: Map<string, TaskSwitcherItem[]>;
} {
  const allIds = new Set(tasks.map((t) => t.id));
  const subMap = new Map<string, TaskSwitcherItem[]>();
  const rootTasks: TaskSwitcherItem[] = [];
  for (const t of tasks) {
    if (t.parentTaskId && allIds.has(t.parentTaskId)) {
      const arr = subMap.get(t.parentTaskId) ?? [];
      arr.push(t);
      subMap.set(t.parentTaskId, arr);
    } else {
      rootTasks.push(t);
    }
  }
  return { rootTasks, subTasksByParentId: subMap };
}

export function applyGroup(
  tasks: TaskSwitcherItem[],
  groupKey: GroupKey,
  effectiveStateSubMap?: Map<string, TaskSwitcherItem[]>,
): GroupedSidebarList {
  const { rootTasks, subTasksByParentId } = separateSubtasks(tasks);

  if (groupKey === "none") {
    return {
      groups: [{ key: "__all__", label: "All", tasks: rootTasks }],
      subTasksByParentId,
    };
  }

  const extract = groupExtractors[groupKey];
  const buckets = new Map<string, SidebarGroup>();
  for (const task of rootTasks) {
    const { key, label } =
      groupKey === "state" && effectiveStateSubMap
        ? getEffectiveStateGroup(task, effectiveStateSubMap)
        : extract(task);
    let group = buckets.get(key);
    if (!group) {
      group = { key, label, tasks: [] };
      buckets.set(key, group);
    }
    group.tasks.push(task);
  }

  const groups = [...buckets.values()];
  if (groupKey === "repository") {
    mergeSingleRepoUnassigned(groups);
    sortRepoGroups(groups);
  }
  if (groupKey === "state") sortStateGroups(groups);
  return { groups, subTasksByParentId };
}

function mergeSingleRepoUnassigned(groups: SidebarGroup[]): void {
  const repoGroups = groups.filter((g) => g.key !== "__multi__" && g.key !== "__unassigned__");
  if (repoGroups.length !== 1) return;
  const unassignedIdx = groups.findIndex((g) => g.key === "__unassigned__");
  if (unassignedIdx === -1) return;
  const unassigned = groups[unassignedIdx];
  repoGroups[0].tasks.push(...unassigned.tasks);
  groups.splice(unassignedIdx, 1);
}

function sortRepoGroups(groups: SidebarGroup[]): void {
  groups.sort((a, b) => {
    if (a.key === "__multi__") return -1;
    if (b.key === "__multi__") return 1;
    if (a.key === "__unassigned__") return 1;
    if (b.key === "__unassigned__") return -1;
    return a.label.localeCompare(b.label);
  });
}

function sortStateGroups(groups: SidebarGroup[]): void {
  groups.sort((a, b) => {
    const order = (STATE_GROUP_ORDER[a.key] ?? 99) - (STATE_GROUP_ORDER[b.key] ?? 99);
    if (order !== 0) return order;
    return a.label.localeCompare(b.label);
  });
}

/**
 * Float pinned tasks to the top within a group, preserving the order the user
 * pinned them in. The active sort still determines the order of unpinned
 * tasks (and acts as a tiebreaker among pinned tasks not in pinIndex).
 */
function floatPinnedToTop(
  tasks: TaskSwitcherItem[],
  pinnedSet: Set<string>,
  pinIndex: Map<string, number>,
): TaskSwitcherItem[] {
  if (pinnedSet.size === 0) return tasks;
  const withSortIndex = tasks.map((t, i) => ({ t, sortIdx: i }));
  withSortIndex.sort((a, b) => {
    const ap = pinnedSet.has(a.t.id);
    const bp = pinnedSet.has(b.t.id);
    if (ap !== bp) return ap ? -1 : 1;
    if (ap && bp) {
      const ai = pinIndex.get(a.t.id) ?? 0;
      const bi = pinIndex.get(b.t.id) ?? 0;
      if (ai !== bi) return ai - bi;
    }
    return a.sortIdx - b.sortIdx;
  });
  return withSortIndex.map((x) => x.t);
}

/**
 * Splice a group's reordered task IDs back into the global manual-order list,
 * preserving the position of *other* groups. Without an anchor, repeatedly
 * appending the dragged group to the end shuffles section headers (the next
 * `applyGroup` pass keys section order off first encounter, so the dragged
 * group always ends up last).
 *
 * Anchor: index of the first existing group task in `current`. If the group
 * is being placed for the first time (`firstIdx === -1`), append at the end —
 * subsequent drags will pin its position via the anchor.
 */
export function mergeGroupOrder(current: string[], groupTaskIds: string[]): string[] {
  const groupSet = new Set(groupTaskIds);
  let firstIdx = -1;
  for (let i = 0; i < current.length; i++) {
    if (groupSet.has(current[i])) {
      firstIdx = i;
      break;
    }
  }
  const remaining = current.filter((id) => !groupSet.has(id));
  if (firstIdx === -1) return [...remaining, ...groupTaskIds];
  // Items before `firstIdx` in `current` are all non-group (firstIdx is the
  // first group occurrence), so translation to `remaining` is identity.
  return [...remaining.slice(0, firstIdx), ...groupTaskIds, ...remaining.slice(firstIdx)];
}

function buildIndex(ids: string[]): Map<string, number> {
  const m = new Map<string, number>();
  for (let i = 0; i < ids.length; i++) m.set(ids[i], i);
  return m;
}

/**
 * Sort subtasks of a single parent by the user's manual order. Listed
 * subtasks come first in their stored order; unlisted ones keep their incoming
 * order (which reflects the active sort) afterwards.
 */
function applySubtaskOrder(
  subtasks: TaskSwitcherItem[],
  orderedSubtaskIds: string[],
): TaskSwitcherItem[] {
  const orderIndex = buildIndex(orderedSubtaskIds);
  const withSortIndex = subtasks.map((t, i) => ({ t, sortIdx: i }));
  withSortIndex.sort((a, b) => {
    const ai = orderIndex.get(a.t.id);
    const bi = orderIndex.get(b.t.id);
    if (ai !== undefined && bi !== undefined) return ai - bi;
    if (ai !== undefined) return -1;
    if (bi !== undefined) return 1;
    return a.sortIdx - b.sortIdx;
  });
  return withSortIndex.map((x) => x.t);
}

/**
 * Count a group's tasks including every nested descendant. The sidebar renders
 * an arbitrarily deep tree, so the header count walks `subTasksByParentId`
 * recursively rather than counting only root + direct children.
 */
export function countGroupTasks(
  rootTasks: TaskSwitcherItem[],
  subTasksByParentId: Map<string, TaskSwitcherItem[]>,
): number {
  let total = 0;
  const visited = new Set<string>();
  const stack = [...rootTasks];
  while (stack.length > 0) {
    const task = stack.pop()!;
    if (visited.has(task.id)) continue;
    visited.add(task.id);
    total += 1;
    const children = subTasksByParentId.get(task.id);
    if (children) stack.push(...children);
  }
  return total;
}

export function applyView(
  tasks: TaskSwitcherItem[],
  view: SidebarView,
  prefs?: SidebarTaskPrefs,
): GroupedSidebarList {
  const filtered = applyFilters(tasks, view.filters);
  const { subTasksByParentId } = separateSubtasks(filtered);
  const sorted = applySort(filtered, view.sort, prefs?.orderedTaskIds, subTasksByParentId);
  const grouped = applyGroup(sorted, view.group, subTasksByParentId);
  const subOrderMap = prefs?.subtaskOrderByParentId;
  if (subOrderMap) {
    for (const [parentId, orderedIds] of Object.entries(subOrderMap)) {
      const subs = grouped.subTasksByParentId.get(parentId);
      if (!subs) continue;
      grouped.subTasksByParentId.set(parentId, applySubtaskOrder(subs, orderedIds));
    }
  }
  if (!prefs || prefs.pinnedTaskIds.length === 0) return grouped;
  const pinnedSet = new Set(prefs.pinnedTaskIds);
  const pinIndex = buildIndex(prefs.pinnedTaskIds);
  for (const group of grouped.groups) {
    group.tasks = floatPinnedToTop(group.tasks, pinnedSet, pinIndex);
  }
  return grouped;
}

export function opIsNegative(op: FilterOp): boolean {
  return op === "is_not" || op === "not_in" || op === "not_matches";
}