<script lang="ts">
  import { getProfile } from "#lib/profile.remote.ts";
  import { START, step, type Phase, type Role } from "#lib/domain.ts";

  const profile = await getProfile();
  const [current, ...past] = profile.roles;

  let phase = $state<Phase>(START);
  const next = $derived(step(profile.loop, phase));

  $effect(() => {
    const then = next;
    if (then === undefined) return;
    const t = setTimeout(() => (phase = then), 4000);
    return () => clearTimeout(t);
  });
</script>

{#snippet tenure({ role, org, from, to }: Role)}
  <li>{role} at {org}, {from} to {to ?? "now"}</li>
{/snippet}

<h1>{profile.name} is a {profile.desc}</h1>

{#if profile.species === "goblin"}
  <p>now: {phase}</p>
  <p>next: {next}</p>
  <p>and after rebuilding? {profile.loop.rebuilding}</p>
{:else}
  <p>now: {phase}</p>
  <p>next: {next ?? "nothing. they shipped."}</p>
{/if}

<ul>
  {@render tenure(current)}
  {#each past as role (`${role.org}/${role.role}/${role.from}`)}
    {@render tenure(role)}
  {/each}
</ul>

import { prerender } from "$app/server";
import { describe } from "#lib/describe.ts";
import type { AnyProfile } from "#lib/domain.ts";
import { jason } from "#db/facts.ts";

export const getProfile = prerender(async (): Promise<AnyProfile> => describe(jason));

import { LOOP, type AnyProfile, type Being, type Profile } from "./domain.ts";
import { roles } from "#db/facts.ts";

function isJason(being: Being): being is Being & { readonly name: "Jason" } {
  return being.name === "Jason";
}

export function describe(being: Being & { readonly name: "Jason" }): Profile<"goblin">;
export function describe(being: Being): Profile<"human">;
export function describe(being: Being): AnyProfile {
  if (isJason(being)) {
    return {
      ...being,
      species: "goblin",
      desc: "neurodivergent anarchosocialist goblin",
      roles: roles.jason,
      loop: LOOP.goblin,
    };
  }

  return {
    ...being,
    species: "human",
    desc: "pro fullstack dev",
    roles: roles.anyone,
    loop: LOOP.human,
  };
}

// ---- primitives

type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
type Month = `0${Exclude<Digit, 0>}` | "10" | "11" | "12";
export type YearMonth = `${number}-${Month}`;
export type Handle = `@${string}`;

// ---- roles

interface Tenure {
  readonly org: Handle;
  readonly role: string;
  readonly level?: string;
  readonly from: YearMonth;
}
export type CurrentRole = Tenure & { readonly to?: never };
export type PastRole = Tenure & { readonly to: YearMonth };
export type Role = CurrentRole | PastRole;
export type Timeline = readonly [CurrentRole, ...PastRole[]];

// ---- species

export type Species = "human" | "goblin";

type Adjective<S extends Species> = S extends "goblin"
  ? "neurodivergent" | "anarchosocialist"
  : "pro" | "fullstack";
type Noun<S extends Species> = S extends "goblin" ? "goblin" : "dev";
type Pair<A extends string, B extends string = A> = A extends unknown
  ? `${A} ${Exclude<B, A>}`
  : never;
export type Desc<S extends Species> = `${Pair<Adjective<S>>} ${Noun<S>}`;

export interface Being {
  readonly name: string;
  readonly handle: Handle;
  readonly stack: readonly string[];
}

// ---- the loop

export type Phase =
  | "fixing a small thing"
  | "questioning the foundations"
  | "rebuilding"
  | "shipped";

export const LOOP = {
  goblin: {
    "fixing a small thing": "questioning the foundations",
    "questioning the foundations": "rebuilding",
    rebuilding: "fixing a small thing",
  },
  human: {
    "fixing a small thing": "shipped",
  },
} as const satisfies { readonly [S in Species]: { readonly [P in Phase]?: Phase } };

export const START = "fixing a small thing" satisfies Phase;

export type Machine<S extends Species> = (typeof LOOP)[S];
export const step = (machine: Partial<Record<Phase, Phase>>, phase: Phase) => machine[phase];
export type Next<S extends Species, P extends Phase> = P extends keyof Machine<S>
  ? Machine<S>[P]
  : never;

// ---- profile

export interface Profile<S extends Species = Species> extends Being {
  readonly species: S;
  readonly desc: Desc<S>;
  readonly roles: Timeline;
  readonly loop: Machine<S>;
}
export type AnyProfile = { [S in Species]: Profile<S> }[Species];

import type { Being, Timeline } from "#lib/domain.ts";

export const jason = {
  name: "Jason",
  handle: "@JasonWarrenUK",
  stack: ["svelte", "bun", "go", "python", "claude"],
} as const satisfies Being;

export const roles = {
  jason: [
    { org: "@TandemCreativeDev", role: "developer", from: "2026-06" },
    { org: "@foundersandcoders", role: "apprentice dev", level: "mid/senior (shhh)", from: "2025-01", to: "2026-06" },
    { org: "@foundersandcoders", role: "L6 AI apprenticeship mentor", from: "2025-01", to: "2026-06" },
    { org: "@FAC-31", role: "facilitator", from: "2025-02", to: "2025-07" },
    { org: "@foundersandcoders", role: "dev", from: "2024-09", to: "2025-01" },
    { org: "@fac30", role: "grad", from: "2024-09", to: "2024-12" },
    { org: "@FAC29A", role: "grad", from: "2023-09", to: "2023-11" },
  ],
  anyone: [
    { org: "@techStartUp", role: "innovation engineer", from: "2024-01" },
  ],
} as const satisfies { readonly [who: string]: Timeline };

import { suite, test, expect, expectTypeOf } from "vitest";
import { describe } from "./describe.ts";
import { jason } from "#db/facts.ts";
import type { Profile } from "./domain.ts";

suite("the compiler knows", () => {
  test("jason is a goblin", () => {
    const profile = describe(jason);
    expectTypeOf(profile).toEqualTypeOf<Profile<"goblin">>();
    expect(profile.desc).toBe("neurodivergent anarchosocialist goblin");
  });

  test("everyone else is a professional", () => {
    const profile = describe({ name: "Dave", handle: "@dave", stack: ["react"] });
    expectTypeOf(profile).toEqualTypeOf<Profile<"human">>();
    expect(profile.loop["fixing a small thing"]).toBe("shipped");
  });

  test("there is no promotion out of goblin", () => {
    // @ts-expect-error Type '"goblin"' is not assignable to type '"human"'
    const pro: Profile<"human"> = describe(jason);
    expect(pro.species).toBe("goblin");
  });
});