import { flip } from "svelte/animate";

  import { crossfade } from "svelte/transition";

  import { array, boolean, string } from "zod";

  import useDragReorder from "@app/lib/useDragReorder.svelte";

  let mounted = $state(false);

    requestAnimationFrame(() => {

      mounted = true;

    });

  const pinnedRepoIds = useLocalStorage<string[]>(

    "sidebarPinnedRepos",

    array(string()),

    [],

    !window.localStorage,

  );

  const pinnedRepos = $derived.by(() => {

    const byRid = new Map(repos.map(r => [r.rid, r]));

    return pinnedRepoIds.value

      .map(rid => byRid.get(rid))

      .filter((r): r is RepoSummary => r !== undefined);

  });

  const unpinnedFilteredRepos = $derived(

    filteredRepos.filter(r => !pinnedRepoIds.value.includes(r.rid)),

  );

  const unpinnedReposCount = $derived(repos.length - pinnedRepos.length);

  function togglePin(rid: string) {

    if (pinnedRepoIds.value.includes(rid)) {

      pinnedRepoIds.value = pinnedRepoIds.value.filter(r => r !== rid);

    } else {

      pinnedRepoIds.value = [rid, ...pinnedRepoIds.value];

    }

  }

  const ANIM_MS = 220;

  const animDuration = $derived(mounted ? ANIM_MS : 0);

  const [send, receive] = crossfade({

    duration: ANIM_MS,

    fallback: () => ({ duration: 0 }),

  });

  const drag = useDragReorder({

    items: () => pinnedRepos,

    getRid: r => r.rid,

    getOrder: () => pinnedRepoIds.value,

    setOrder: rids => (pinnedRepoIds.value = rids),

    listSelector: ".pinned-list",

    rowAttribute: "data-drag-rid",

    bodyDragClass: "dragging-pinned-repo",

  });

  .pinned-list.empty {

    height: 0;

    padding: 0;

    overflow: visible;

  }

  .filter-button {

    display: flex;

    align-items: center;

    justify-content: center;

    background: none;

    border: 0;

    padding: 0.125rem;

    margin-left: -0.125rem;

    border-radius: var(--border-radius-sm);

    color: var(--color-text-secondary);

    cursor: pointer;

  }

  .filter-button:hover {

    color: var(--color-text-primary);

    background-color: var(--color-surface-subtle);

  }

  .filter-input {

    background: none;

    border: 0;

    outline: none;

    font: var(--txt-body-m-regular);

    color: var(--color-text-primary);

    flex: 1;

    min-width: 0;

  }

  .filter-input::placeholder {

    color: var(--color-text-secondary);

  }

    position: relative;

    user-select: none;

    -webkit-user-select: none;

  }

  .nav-item :global(img),

  .nav-item :global(svg) {

    -webkit-user-drag: none;

  .nav-item .row-actions {

    display: flex;

    align-items: center;

    gap: 0.125rem;

  .nav-item:hover .row-actions,

  .nav-item .row-actions:focus-within {

  .nav-item .row-actions :global(.clipboard),

  .nav-item .row-actions .pin-button {

    border-radius: var(--border-radius-sm);

    padding: 0.0625rem;

  }

  .nav-item .row-actions :global(.clipboard):hover,

  .nav-item .row-actions .pin-button:hover {

    background-color: var(--color-surface-mid);

  }

  .pin-button {

    color: inherit;

  .repo-row-group {

    position: relative;

    display: flex;

    flex-direction: column;

    gap: 0.25rem;

  }

  .repo-row-group.drop-before::before,

  .repo-row-group.drop-after::after {

    content: "";

    position: absolute;

    left: 0;

    right: 0;

    height: 2px;

    background-color: var(--color-border-mid);

    border-radius: 1px;

    pointer-events: none;

  }

  .repo-row-group.drop-before::before {

    top: -3px;

  }

  .repo-row-group.drop-after::after {

    bottom: -3px;

  }

  .nav-item.dragging {

    opacity: 0.35;

  :global(body.dragging-pinned-repo),

  :global(body.dragging-pinned-repo *) {

    cursor: grabbing !important;

  }

  .drag-ghost {

    position: fixed;

    pointer-events: none;

    z-index: 9999;

    display: flex;

    align-items: center;

    gap: 0.5rem;

    padding: 0.375rem 0.5rem;

    background-color: var(--color-surface-strong);

    border: 1px solid var(--color-border-mid);

    border-radius: var(--border-radius-sm);

    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);

    max-width: 14rem;

<div class="repos-list pinned-list" class:empty={pinnedRepos.length === 0}>

  {#each pinnedRepos as repo (repo.rid)}

    <div

      class="repo-row-group"

      class:drop-before={drag.dropTargetRid === repo.rid &&

        drag.dropPosition === "before" &&

        drag.draggingRid !== repo.rid}

      class:drop-after={drag.dropTargetRid === repo.rid &&

        drag.dropPosition === "after" &&

        drag.draggingRid !== repo.rid}

      data-drag-rid={repo.rid}

      animate:flip={{ duration: animDuration }}

      in:receive={{ key: repo.rid, duration: animDuration }}

      out:send={{ key: repo.rid, duration: animDuration }}>

      {@render repoRowInner(repo, true)}

    </div>

  {/each}

</div>

      All Repos{unpinnedReposCount > 1 ? ` (${unpinnedReposCount})` : ""}

{#snippet repoRowInner(repo: RepoSummary, pinned: boolean = false)}

  {@const pinState = pinnedRepoIds.value.includes(repo.rid)}

  <a

    class="nav-item"

    class:active={isRepoHome(repo.rid)}

    class:dragging={pinned && drag.draggingRid === repo.rid}

    draggable="false"

    onmousedown={pinned ? e => drag.onMouseDown(e, repo.rid) : undefined}

    onclick={pinned ? drag.onClick : undefined}

    href={router.routeToPath({ resource: "repo.home", rid: repo.rid })}>

    <RepoAvatar name={repo.name} rid={repo.rid} styleWidth="1rem" />

    <span class="txt-overflow">{repo.name}</span>

    <span

      class="row-actions"

      role="none"

      onclick={e => {

        e.preventDefault();

        e.stopPropagation();

      }}>

      <button

        class="pin-button"

        title={pinState ? "Unpin repository" : "Pin repository"}

        onclick={() => togglePin(repo.rid)}>

        <Icon name={pinState ? "pin-filled" : "pin-hollow"} />

      </button>

      <span title="Copy RID">

        <Clipboard text={repo.rid} noPopover />

      </span>

    </span>

  </a>

  {#if activeRid() === repo.rid}

    {@const activeProject = activeRepo?.payloads["xyz.radicle.project"]}

    {@render subItem(

      router.routeToPath({ resource: "repo.commits", rid: repo.rid }),

      "branch",

      "Commits",

      isCommits(repo.rid),

      activeCommitCount,

    )}

    {@render subItem(

      router.routeToPath({

        resource: "repo.issues",

        rid: repo.rid,

        status: "open",

      }),

      "issue",

      "Issues",

      isIssues(repo.rid),

      activeProject?.meta.issues.open || undefined,

    )}

    {@render subItem(

      router.routeToPath({

        resource: "repo.patches",

        rid: repo.rid,

        status: "open",

      }),

      "patch",

      "Patches",

      isPatches(repo.rid),

      activeProject?.meta.patches.open || undefined,

    )}

  {/if}

{/snippet}

{#snippet subItem(

  href: string,

  icon: "branch" | "issue" | "patch",

  label: string,

  active: boolean,

  count: number | undefined,

)}

  <a class="nav-item sub-item" class:active {href}>

    <span class="icon"><Icon name={icon} /></span>

    {label}

    {#if count !== undefined}

      <span class="global-counter-badge">{count}</span>

    {/if}

  </a>

{/snippet}

      {#each unpinnedFilteredRepos as repo (repo.rid)}

        <div

          class="repo-row-group"

          animate:flip={{ duration: animDuration }}

          in:receive={{ key: repo.rid, duration: animDuration }}

          out:send={{ key: repo.rid, duration: animDuration }}>

          {@render repoRowInner(repo, false)}

        </div>

{#if drag.draggedItem}

  <div

    class="drag-ghost"

    style:left="{drag.ghostX + 12}px"

    style:top="{drag.ghostY + 8}px">

    <RepoAvatar

      name={drag.draggedItem.name}

      rid={drag.draggedItem.rid}

      styleWidth="1rem" />

    <span class="txt-overflow">{drag.draggedItem.name}</span>

  </div>

{/if}

interface DragReorderOptions<T> {

  items: () => T[];

  getRid: (item: T) => string;

  getOrder: () => string[];

  setOrder: (rids: string[]) => void;

  listSelector: string;

  rowAttribute: string;

  bodyDragClass?: string;

  thresholdPx?: number;

}

export default function useDragReorder<T>(options: DragReorderOptions<T>) {

  const threshold = options.thresholdPx ?? 4;

  let dragStart: { rid: string; x: number; y: number } | undefined;

  let suppressClick = false;

  let draggingRid = $state<string | undefined>(undefined);

  let dropTargetRid = $state<string | undefined>(undefined);

  let dropPosition = $state<"before" | "after" | undefined>(undefined);

  let ghostX = $state(0);

  let ghostY = $state(0);

  const draggedItem = $derived(

    draggingRid !== undefined

      ? options.items().find(item => options.getRid(item) === draggingRid)

      : undefined,

  );

  $effect(() => {

    if (draggingRid !== undefined && options.bodyDragClass) {

      const cls = options.bodyDragClass;

      document.body.classList.add(cls);

      return () => document.body.classList.remove(cls);

    }

  });

  $effect(() => {

    return () => {

      window.removeEventListener("mousemove", onWindowMouseMove);

      window.removeEventListener("mouseup", onWindowMouseUp);

    };

  });

  function onMouseDown(e: MouseEvent, rid: string) {

    if (e.button !== 0) return;

    const target = e.target as HTMLElement;

    if (target.closest("button, .clipboard")) return;

    suppressClick = false;

    dragStart = { rid, x: e.clientX, y: e.clientY };

    window.addEventListener("mousemove", onWindowMouseMove);

    window.addEventListener("mouseup", onWindowMouseUp);

  }

  function onWindowMouseMove(e: MouseEvent) {

    if (!dragStart) return;

    if (!draggingRid) {

      const dx = e.clientX - dragStart.x;

      const dy = e.clientY - dragStart.y;

      if (Math.hypot(dx, dy) < threshold) return;

      draggingRid = dragStart.rid;

    }

    ghostX = e.clientX;

    ghostY = e.clientY;

    updateDropTarget(e.clientX, e.clientY);

  }

  function updateDropTarget(x: number, y: number) {

    const el = document.elementFromPoint(x, y) as HTMLElement | null;

    const list = el?.closest(options.listSelector) as HTMLElement | null;

    if (!list) {

      dropTargetRid = undefined;

      dropPosition = undefined;

      return;

    }

    let row = el?.closest(`[${options.rowAttribute}]`) as HTMLElement | null;

    if (!row) {

      const rows = Array.from(

        list.querySelectorAll(`[${options.rowAttribute}]`),

      ) as HTMLElement[];

      let nearestDistance = Infinity;

      for (const r of rows) {

        const rect = r.getBoundingClientRect();

        const distance = Math.abs(y - (rect.top + rect.height / 2));

        if (distance < nearestDistance) {

          nearestDistance = distance;

          row = r;

        }

      }

    }

    if (!row) return;

    const rid = row.getAttribute(options.rowAttribute);

    if (!rid) return;

    const rect = row.getBoundingClientRect();

    dropTargetRid = rid;

    dropPosition = y - rect.top < rect.height / 2 ? "before" : "after";

  }

  function onWindowMouseUp() {

    window.removeEventListener("mousemove", onWindowMouseMove);

    window.removeEventListener("mouseup", onWindowMouseUp);

    const dragging = draggingRid;

    const target = dropTargetRid;

    const position = dropPosition;

    if (dragging && target && position && dragging !== target) {

      const without = options.getOrder().filter(r => r !== dragging);

      const targetIdx = without.indexOf(target);

      if (targetIdx !== -1) {

        const insertAt = position === "after" ? targetIdx + 1 : targetIdx;

        without.splice(insertAt, 0, dragging);

        options.setOrder(without);

      }

    }

    suppressClick = dragging !== undefined;

    dragStart = undefined;

    draggingRid = undefined;

    dropTargetRid = undefined;

    dropPosition = undefined;

  }

  function onClick(e: MouseEvent) {

    if (suppressClick) {

      e.preventDefault();

      e.stopPropagation();

      suppressClick = false;

    }

  }

  return {

    get draggingRid() {

      return draggingRid;

    },

    get dropTargetRid() {

      return dropTargetRid;

    },

    get dropPosition() {

      return dropPosition;

    },

    get draggedItem() {

      return draggedItem;

    },

    get ghostX() {

      return ghostX;

    },

    get ghostY() {

      return ghostY;

    },

    onMouseDown,

    onClick,

  };

}