Sample data

// The sample-data kit item. `core.ts` documents the pattern every entity
// module follows; each module below adds three lines here — its `export *`, its
// import, and its key on `db` — all kept in alphabetical order.
import { aiRequests } from "./ai-requests"
import { aiThreads } from "./ai-threads"
import { alerts } from "./alerts"
import { apiKeys } from "./api-keys"
import { appointments } from "./appointments"
import { articles } from "./articles"
import { auditEvents } from "./audit-events"
import { bookings } from "./bookings"
import { campaigns } from "./campaigns"
import { chats } from "./chats"
import { cohorts } from "./cohorts"
import { comments } from "./comments"
import { courses } from "./courses"
import { customers } from "./customers"
import { deals } from "./deals"
import { deployments } from "./deployments"
import { employees } from "./employees"
import { events } from "./events"
import { files } from "./files"
import { fxRates } from "./fx-rates"
import { generations } from "./generations"
import { holdings } from "./holdings"
import { incidents } from "./incidents"
import { integrations } from "./integrations"
import { invitations } from "./invitations"
import { invoices } from "./invoices"
import { leads } from "./leads"
import { leaves } from "./leaves"
import { listings } from "./listings"
import { logEntries } from "./log-entries"
import { mails } from "./mails"
import { members } from "./members"
import { messages } from "./messages"
import { notes } from "./notes"
import { notifications } from "./notifications"
import { orders } from "./orders"
import { paymentMethods } from "./payment-methods"
import { plans } from "./plans"
import { posts } from "./posts"
import { products } from "./products"
import { projects } from "./projects"
import { releases } from "./releases"
import { reviews } from "./reviews"
import { roles } from "./roles"
import { services } from "./services"
import { sessions } from "./sessions"
import { shipments } from "./shipments"
import { students } from "./students"
import { subscriptions } from "./subscriptions"
import { tasks } from "./tasks"
import { trades } from "./trades"
import { transactions } from "./transactions"
import { voiceJobs } from "./voice-jobs"
import { workflows } from "./workflows"

export * from "./ai-requests"
export * from "./ai-threads"
export * from "./alerts"
export * from "./api-keys"
export * from "./appointments"
export * from "./articles"
export * from "./audit-events"
export * from "./avatars"
export * from "./bookings"
export * from "./campaigns"
export * from "./chats"
export * from "./cohorts"
export * from "./comments"
export * from "./core"
export * from "./courses"
export * from "./customers"
export * from "./deals"
export * from "./deployments"
export * from "./employees"
export * from "./events"
export * from "./files"
export * from "./fx-rates"
export * from "./generations"
export * from "./holdings"
export * from "./incidents"
// The checks a server action reads its arguments through; not an entity.
export * from "./input"
export * from "./integrations"
export * from "./invitations"
export * from "./invoices"
export * from "./leads"
export * from "./leaves"
export * from "./listings"
export * from "./log-entries"
export * from "./mails"
export * from "./members"
export * from "./messages"
export * from "./notes"
export * from "./notifications"
export * from "./orders"
export * from "./payment-methods"
export * from "./plans"
export * from "./posts"
export * from "./products"
export * from "./projects"
export * from "./releases"
export * from "./reviews"
export * from "./roles"
// A selector over members, invitations and plans, not an entity: no key on `db`.
export * from "./seats"
export * from "./services"
export * from "./sessions"
export * from "./shipments"
export * from "./students"
export * from "./subscriptions"
export * from "./tasks"
export * from "./trades"
export * from "./transactions"
export * from "./voice-jobs"
export * from "./workflows"

/**
 * The one handle a block reads through: `db.customers.list({ page: 2 })` for a
 * table, `db.customers.all()` for a chart. Swap any entry for a repository
 * backed by a real store and the blocks above it keep working. One entry is
 * not a repository: `db.fxRates` is a year of daily rates per currency pair,
 * read whole by pair and never written, so it is held as the record it is.
 */
export const db = {
  aiRequests,
  aiThreads,
  alerts,
  apiKeys,
  appointments,
  articles,
  auditEvents,
  bookings,
  campaigns,
  chats,
  cohorts,
  comments,
  courses,
  customers,
  deals,
  deployments,
  employees,
  events,
  files,
  fxRates,
  generations,
  holdings,
  incidents,
  integrations,
  invitations,
  invoices,
  leads,
  leaves,
  listings,
  logEntries,
  mails,
  members,
  messages,
  notes,
  notifications,
  orders,
  paymentMethods,
  plans,
  posts,
  products,
  projects,
  releases,
  reviews,
  roles,
  services,
  sessions,
  shipments,
  students,
  subscriptions,
  tasks,
  trades,
  transactions,
  voiceJobs,
  workflows,
}

import { REFERENCE_DATE, createRepository, dateBetween, daysAgo, intBetween, pick, pickWeighted, rowId, seeded } from "./core"

/**
 * One call to a hosted LLM, logged for usage and cost tracking. The providers
 * are fictional — Sparrowmere Labs, Galewright AI and Ternstead AI, and
 * Northwind's own models run in-house — and so are their models: the kit
 * names no real AI company, and no demo reads as anyone's price list.
 */
export type AiRequest = {
  id: string
  at: Date
  model: string
  provider: "sparrowmere" | "galewright" | "ternstead" | "northwind"
  promptTokens: number
  completionTokens: number
  latencyMs: number
  /** Cost in minor units — cents, not dollars. 0 for a request that failed. */
  costCents: number
  status: 200 | 429 | 500
  traceId: string
}

const COUNT = 3000

// Each provider's line-up, a current generation beside the one before it.
// Northwind's in-house family is the one the assistant pages offer.
const MODELS_BY_PROVIDER: Record<AiRequest["provider"], string[]> = {
  sparrowmere: ["sparrowmere-3", "sparrowmere-3-mini", "sparrowmere-2.5", "sparrowmere-2.5-mini"],
  galewright: ["galewright-pro", "galewright-ultra", "galewright-lite"],
  ternstead: ["ternstead-2-pro", "ternstead-2-lite", "ternstead-1-pro"],
  northwind: ["nw-large-2", "nw-fast-2", "nw-2"],
}

const PROVIDER_MIX: readonly (readonly [AiRequest["provider"], number])[] = [
  ["sparrowmere", 0.4],
  ["galewright", 0.35],
  ["ternstead", 0.15],
  ["northwind", 0.1],
]

const STATUS_MIX: readonly (readonly [AiRequest["status"], number])[] = [
  [200, 0.92],
  [429, 0.05],
  [500, 0.03],
]

/**
 * Cents per 1,000 tokens — illustrative, not a real price list. Galewright is
 * the dearest, Ternstead the cheapest of the three hosted, and the in-house
 * models cost little more than the machines they run on.
 */
const RATE_PER_1K: Record<AiRequest["provider"], { prompt: number; completion: number }> = {
  sparrowmere: { prompt: 50, completion: 150 },
  galewright: { prompt: 60, completion: 180 },
  ternstead: { prompt: 30, completion: 100 },
  northwind: { prompt: 5, completion: 8 },
}

const HEX = "0123456789abcdef"
function hex(rand: () => number, length: number): string {
  return Array.from({ length }, () => HEX[Math.floor(rand() * HEX.length)]).join("")
}

function generate(): AiRequest[] {
  const rand = seeded("aiRequests")
  return Array.from({ length: COUNT }, (_, index) => {
    const provider = pickWeighted(rand, PROVIDER_MIX)
    const status = pickWeighted(rand, STATUS_MIX)
    const promptTokens = intBetween(rand, 50, 4_000)
    // A throttled or failed call rarely produces much, if any, completion.
    const completionTokens = status === 200 ? intBetween(rand, 10, 2_000) : intBetween(rand, 0, 20)
    const rate = RATE_PER_1K[provider]
    const cost = Math.round((promptTokens / 1000) * rate.prompt + (completionTokens / 1000) * rate.completion)

    return {
      id: rowId("aiq", index + 1),
      at: dateBetween(rand, daysAgo(30), REFERENCE_DATE),
      model: pick(rand, MODELS_BY_PROVIDER[provider]),
      provider,
      promptTokens,
      completionTokens,
      latencyMs: 150 + completionTokens * intBetween(rand, 2, 6) + intBetween(rand, 0, 400),
      // Nobody is billed for a request that failed or was rate-limited.
      costCents: status === 200 ? cost : 0,
      status,
      traceId: `trace_${hex(rand, 12)}`,
    }
  })
}

/** The seeded request log. The repository below owns the rows a demo mutates. */
export const AI_REQUESTS: AiRequest[] = generate()

export const aiRequests = createRepository(AI_REQUESTS, {
  searchKeys: ["model", "traceId"],
  filterKeys: ["provider", "status"],
})

import { chance, createRepository, daysAgo, intBetween, pickWeighted, rowId, seeded } from "./core"

/** One turn in a conversation with the assistant. */
export type AiMessage = {
  id: string
  role: "user" | "assistant"
  text: string
  at: Date
}

/**
 * A conversation with the assistant: a title for the rail, a model, and the
 * turns. The models are Northwind's own, run in-house: the default, the large
 * one and the fast one — fictional, like every AI name in the kit.
 */
export type AiThread = {
  id: string
  title: string
  model: "nw-2" | "nw-large-2" | "nw-fast-2"
  createdAt: Date
  /** When the last turn landed; the rail groups threads by it. */
  updatedAt: Date
  /** Alternating user and assistant turns, opening on the user and closing on the assistant. */
  messages: AiMessage[]
}

const COUNT = 12

const MODEL_MIX: readonly (readonly [AiThread["model"], number])[] = [
  ["nw-2", 0.6],
  ["nw-large-2", 0.25],
  ["nw-fast-2", 0.15],
]

// What a product team asks an assistant inside its own analytics workspace:
// the title the rail shows, the question as it was typed, and the answer.
const OPENERS: readonly { title: string; question: string; answer: string }[] = [
  {
    title: "Summarise last week's signups",
    question: "Can you summarise how signups moved last week and what drove the change?",
    answer:
      "Signups rose about 12% week over week, with most of the lift landing on Tuesday and Wednesday after the launch post went out. Organic search held steady, so the change is almost entirely the referral spike. If you want, I can break the week down by plan.",
  },
  {
    title: "Draft a trial-ending email",
    question: "Draft a short email to customers whose trial ends this week, nudging them to pick a plan.",
    answer:
      "Here is a draft you can adapt: subject “Your trial ends Friday — keep your dashboards”. The body thanks them, names the one feature they used most, and closes with a single link to the plans page. I kept it to four sentences so it reads on a phone.",
  },
  {
    title: "Explain the P95 latency spike",
    question: "Why did P95 latency jump on Monday afternoon?",
    answer:
      "The jump lines up with the 14:10 deploy of the events service: P95 climbed from 380 ms to 1.2 s and settled once the rollback landed at 15:05. Nothing in the traffic mix changed, so it reads as a regression rather than load. The deploy notes mention a new serialisation path, which is the first place I would look.",
  },
  {
    title: "SQL for weekly active workspaces",
    question: "Write a query that counts weekly active workspaces for the last 12 weeks.",
    answer:
      "Group events by workspace and by the Monday of the week they landed in, count the distinct workspaces per week, and keep the last twelve weeks. The trick is to truncate to the week before counting, not after, or a workspace active on two days is counted twice. I have written it to read from the events table with a 12-week window on the timestamp.",
  },
  {
    title: "Rename the onboarding steps",
    question: "Suggest clearer names for the four onboarding steps: Setup, Connect, Invite, Done.",
    answer:
      "Try “Name your workspace”, “Connect a data source”, “Invite your team” and “You’re all set”. Each one says what the reader does on that step rather than what the step is called, which is what a progress bar needs. The last one can stay a sentence, since it is a state and not a task.",
  },
  {
    title: "Compare the two pricing pages",
    question: "Compare the current pricing page with the draft: which one converts better and why?",
    answer:
      "The draft moves the plan comparison above the fold and drops the toggle for annual billing, which are the two changes most likely to matter. On the current page readers scroll past the plans to find the price, and the toggle hides the number half of them want. I would ship the draft’s layout and keep the annual toggle visible.",
  },
  {
    title: "Regex for order numbers",
    question: "What regex matches our order numbers like ORD-10432?",
    answer:
      "Use ^ORD-\\d{5}$ if the number is always five digits, or ^ORD-\\d{4,6}$ to leave room for growth. Anchor both ends so a longer string with an order number inside it does not match. If you are validating user input, trim whitespace first.",
  },
  {
    title: "Plan the Q4 roadmap doc",
    question: "Help me outline a one-page Q4 roadmap for the platform team.",
    answer:
      "Open with the three outcomes the quarter is for, then one line per project naming the outcome it serves, the owner and the month it lands. Keep risks as a short list at the bottom rather than woven into the projects, so a reader can find them. A page that fits on one screen gets read; the appendix can hold the rest.",
  },
  {
    title: "Plain-English release notes",
    question: "Translate the 2.4 release notes into plain English for the changelog.",
    answer:
      "Here is a plainer version: “Dashboards now load twice as fast, filters remember what you picked, and the export button works on every table.” The original names the caching layer and the state store, which nobody outside the team needs. Three sentences cover the three changes.",
  },
  {
    title: "Explain the retention cohort chart",
    question: "Explain what the retention cohort chart is showing, in one paragraph.",
    answer:
      "Each row is the set of workspaces that signed up in one month, and each cell is the share of them still active some weeks later. Reading down a column compares cohorts at the same age, which is where a product change shows up. The chart is saying that cohorts since May keep about ten points more of their users at week eight.",
  },
  {
    title: "Write a status page notice",
    question: "Write a short incident notice for the status page about the delayed exports.",
    answer:
      "“Exports are delayed. Since 09:20 UTC, CSV exports are taking up to 20 minutes to arrive. Dashboards and the API are unaffected. We have found the cause and expect exports to catch up within the hour; we will update this notice when they do.” Four sentences: what, since when, what still works, what happens next.",
  },
  {
    title: "Tidy a changelog entry",
    question: "Tidy this changelog entry: “fixed bug where the invoice mailer sent twice sometimes when retried”.",
    answer:
      "“Fixed: a retried invoice email could be sent twice.” Lead with the outcome, keep the tense consistent, and drop “sometimes” — a reader wants to know the bug is gone, not how often it struck. If it helps, add the version it shipped in.",
  },
]

const FOLLOW_UPS = [
  "Can you make that shorter?",
  "What would you change if the audience were customers rather than the team?",
  "Give me one more option.",
  "Which part of that is most likely to be wrong?",
  "Can you turn that into three bullet points?",
]

const FOLLOW_UP_ANSWERS = [
  "Shorter version: keep the first sentence, cut the second, and end on the action. That loses the reasoning but keeps the point, which is what a busy reader takes away.",
  "For customers, drop the internal names and say what changes for them. The structure stays the same; only the nouns move.",
  "One more: lead with the number, then the cause, then the next step. It reads more like a status line and less like a memo.",
  "The weakest part is the causal claim: the timing fits, but nothing here proves it. A quick check against the deploy log would settle it either way.",
  "As bullets: what changed, why it matters, what to do next. Each one a single line, and no bullet that needs the one above it to make sense.",
]

const HOUR = 1 / 24
const MINUTE = HOUR / 60

/**
 * When a thread opened, in days before now. The first three opened earlier
 * today, the next two yesterday, the rest over the last six weeks — so the
 * rail's three groups are all populated whichever way the seed falls.
 */
function openedDaysAgo(rand: () => number, index: number): number {
  if (index < 3) return intBetween(rand, 1, 12) * HOUR
  if (index < 5) return intBetween(rand, 26, 36) * HOUR
  return intBetween(rand, 3, 40) + rand()
}

function generate(): AiThread[] {
  const rand = seeded("ai-threads")

  return OPENERS.slice(0, COUNT).map((opener, index) => {
    const id = rowId("ait", index + 1)
    // At least an hour back, and the turns below add under forty minutes
    // between them, so no thread ever runs past "now".
    const openedAt = daysAgo(openedDaysAgo(rand, index))
    let at = openedAt
    let count = 0

    const turn = (role: AiMessage["role"], text: string, gapMinutes: number): AiMessage => {
      at = new Date(at.getTime() + gapMinutes * MINUTE * 86_400_000)
      count += 1
      return { id: `${id}-m${count}`, role, text, at }
    }

    const messages: AiMessage[] = [
      turn("user", opener.question, 0),
      turn("assistant", opener.answer, intBetween(rand, 1, 3)),
    ]

    // A follow-up or two, as a reader who got a useful answer tends to ask.
    const exchanges = chance(rand, 0.55) ? intBetween(rand, 1, 2) : 0
    for (let i = 0; i < exchanges; i += 1) {
      const which = intBetween(rand, 0, FOLLOW_UPS.length - 1)
      messages.push(turn("user", FOLLOW_UPS[which], intBetween(rand, 2, 15)))
      messages.push(turn("assistant", FOLLOW_UP_ANSWERS[which], intBetween(rand, 1, 3)))
    }

    return {
      id,
      title: opener.title,
      model: pickWeighted(rand, MODEL_MIX),
      createdAt: openedAt,
      updatedAt: messages[messages.length - 1].at,
      messages,
    }
  })
}

/** The seeded conversations. The repository below owns the rows the assistant page appends to. */
export const AI_THREADS: AiThread[] = generate()

export const aiThreads = createRepository(AI_THREADS, {
  searchKeys: ["title"],
  filterKeys: ["model"],
})

import { REFERENCE_DATE, chance, createRepository, dateBetween, daysAgo, pick, pickWeighted, rowId, seeded } from "./core"

/** A monitoring rule and its current firing state. */
export type Alert = {
  id: string
  name: string
  condition: string
  /** Reuses the incident severity scale so the two read together on a dashboard. */
  severity: "sev1" | "sev2" | "sev3"
  status: "firing" | "resolved" | "silenced"
  firedAt?: Date
  /**
   * What the rule was doing when it was muted, so lifting a silence puts it
   * back rather than guessing — a resolved rule someone quietened must not
   * come back firing. Read it only while `status` is "silenced": resuming
   * leaves it behind as the record of the silence that was lifted.
   */
  silencedFrom?: "firing" | "resolved"
  /** When the silence runs out. Same rule: meaningful only while silenced. */
  silencedUntil?: Date
  channel: "chat" | "email" | "pager"
}

const COUNT = 30

const ALERT_DEFS: { name: string; condition: string; severity: Alert["severity"] }[] = [
  { name: "High CPU usage", condition: "CPU utilization > 90% for 5m", severity: "sev2" },
  { name: "Elevated error rate", condition: "5xx rate > 2% for 10m", severity: "sev1" },
  { name: "Slow API responses", condition: "p99 latency > 800ms for 5m", severity: "sev2" },
  { name: "Low disk space", condition: "disk usage > 85%", severity: "sev3" },
  { name: "Queue backlog growing", condition: "queue depth > 10,000 for 15m", severity: "sev2" },
  { name: "Memory pressure", condition: "memory utilization > 92% for 5m", severity: "sev2" },
  { name: "Database connections exhausted", condition: "connection pool usage > 95%", severity: "sev1" },
  { name: "Failed login spike", condition: "failed logins > 50 in 5m", severity: "sev3" },
  { name: "Certificate expiring soon", condition: "TLS certificate expires in < 14 days", severity: "sev3" },
  { name: "Deployment failure", condition: "deployment status = failed", severity: "sev2" },
  { name: "Webhook delivery failures", condition: "webhook failure rate > 5% for 10m", severity: "sev3" },
  { name: "Replication lag", condition: "database replica lag > 30s", severity: "sev2" },
]

const STATUS_MIX: readonly (readonly [Alert["status"], number])[] = [
  ["resolved", 0.55],
  ["silenced", 0.25],
  ["firing", 0.2],
]

const CHANNEL_MIX: readonly (readonly [Alert["channel"], number])[] = [
  ["chat", 0.55],
  ["pager", 0.28],
  ["email", 0.17],
]

// How recently a rule must have fired for it to still be the one going off,
// which is what a silence seeded into the store was muting.
const RECENT_FIRE_MS = 3 * 86_400_000

/** The longest a seeded silence can still have to run. */
const MAX_SILENCE_MS = 30 * 86_400_000

function firedAtFor(rand: () => number, status: Alert["status"]): Date | undefined {
  if (status === "firing") return dateBetween(rand, daysAgo(3), REFERENCE_DATE)
  if (status === "resolved") return chance(rand, 0.9) ? dateBetween(rand, daysAgo(90), daysAgo(1)) : undefined
  // Silenced: sometimes it fired before being muted, often it never has.
  return chance(rand, 0.3) ? dateBetween(rand, daysAgo(120), daysAgo(10)) : undefined
}

function generate(): Alert[] {
  const rand = seeded("alerts")
  return Array.from({ length: COUNT }, (_, index) => {
    const def = pick(rand, ALERT_DEFS)
    const status = pickWeighted(rand, STATUS_MIX)
    const firedAt = firedAtFor(rand, status)
    const silenced = status === "silenced"
    return {
      id: rowId("alr", index + 1),
      name: def.name,
      condition: def.condition,
      severity: def.severity,
      status,
      firedAt,
      // A silence in the store is one somebody started before the demo did, so
      // it carries the same two facts a silence started inside it does: what
      // the rule was doing, and how long the quiet lasts.
      silencedFrom: silenced
        ? firedAt && REFERENCE_DATE.getTime() - firedAt.getTime() <= RECENT_FIRE_MS
          ? ("firing" as const)
          : ("resolved" as const)
        : undefined,
      silencedUntil: silenced
        ? dateBetween(rand, REFERENCE_DATE, new Date(REFERENCE_DATE.getTime() + MAX_SILENCE_MS))
        : undefined,
      channel: pickWeighted(rand, CHANNEL_MIX),
    }
  })
}

/** The seeded alert rules. The repository below owns the rows a demo mutates. */
export const ALERTS: Alert[] = generate()

export const alerts = createRepository(ALERTS, {
  searchKeys: ["name", "condition"],
  filterKeys: ["severity", "status", "channel"],
})

import { REFERENCE_DATE, chance, createRepository, dateBetween, daysAgo, intBetween, pick, pickWeighted, rowId, seeded, shuffle } from "./core"
import { MEMBERS } from "./members"

/** A workspace API key, shown to the user only as its prefix once created. */
export type ApiKey = {
  id: string
  name: string
  prefix: string
  lastUsedAt?: Date
  createdAt: Date
  /** A Member id: whoever generated the key. */
  createdBy: string
  scopes: string[]
  status: "active" | "revoked"
}

const COUNT = 12

const NAME_POOL = [
  "Production Server", "CI Pipeline", "Local Development", "Workflow Automation",
  "Mobile App", "Analytics Export", "Staging Environment", "Backup Script",
  "Partner API - Blue Harbor", "Data Warehouse Sync", "Support Tooling", "Billing Reconciliation",
  "Monitoring Agent", "Internal Dashboard",
]

const SCOPE_POOL = [
  "read:customers", "write:customers", "read:invoices", "write:invoices",
  "read:analytics", "read:deployments", "write:deployments", "admin",
]

const STATUS_MIX: readonly (readonly [ApiKey["status"], number])[] = [
  ["active", 0.75],
  ["revoked", 0.25],
]

const TOKEN_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789"

/** A short opaque token — the only part of the real key ever shown again. */
function token(rand: () => number, length: number): string {
  return Array.from({ length }, () => TOKEN_CHARS[Math.floor(rand() * TOKEN_CHARS.length)]).join("")
}

function generate(): ApiKey[] {
  const rand = seeded("apiKeys")
  const names = shuffle(rand, NAME_POOL).slice(0, COUNT)
  const creators = MEMBERS.filter((member) => member.status === "active" && member.role !== "viewer").map(
    (member) => member.id
  )

  return names.map((name, index) => {
    const status = pickWeighted(rand, STATUS_MIX)
    const ageDays = intBetween(rand, 5, 500)
    const createdAt = dateBetween(rand, daysAgo(ageDays), daysAgo(ageDays - 1))
    const lastUsedAt =
      status === "revoked"
        ? chance(rand, 0.7)
          ? dateBetween(rand, createdAt, daysAgo(30))
          : undefined
        : chance(rand, 0.85)
          ? dateBetween(rand, createdAt, REFERENCE_DATE)
          : undefined

    return {
      id: rowId("key", index + 1),
      name,
      prefix: `sk_live_${token(rand, 6)}`,
      lastUsedAt,
      createdAt,
      createdBy: pick(rand, creators),
      scopes: shuffle(rand, SCOPE_POOL).slice(0, intBetween(rand, 1, 4)),
      status,
    }
  })
}

/** The seeded API keys. The repository below owns the rows a demo mutates. */
export const API_KEYS: ApiKey[] = generate()

export const apiKeys = createRepository(API_KEYS, {
  searchKeys: ["name", "prefix"],
  filterKeys: ["status"],
})

import {
  REFERENCE_DATE,
  chance,
  createRepository,
  daysAhead,
  emailFor,
  intBetween,
  pick,
  pickWeighted,
  rowId,
  seeded,
} from "./core"
import { avatarFor } from "./avatars"

/** One booked visit at the clinic: who, with whom, when, and what came of it. */
export type Appointment = {
  id: string
  patient: string
  /** A face for the patient — the kit's own avatar route for the name — */
  avatarUrl?: string
  email: string
  /** "Dr. Amara Osei" — written the way the schedule prints it. */
  doctor: string
  department: "Cardiology" | "Neurology" | "Oncology" | "Pediatrics" | "Orthopedics"
  at: Date
  durationMin: number
  status: "scheduled" | "checked_in" | "done" | "cancelled"
  /** What was done, when the visit was more than a consultation. */
  procedure?: string
  /** True when this visit was the patient's first at the clinic. */
  isNewPatient: boolean
}

const COUNT = 160

const FIRST_NAMES = [
  "Ana", "Bilal", "Clara", "Daniel", "Elif", "Femi", "Grace", "Hugo",
  "Ines", "Jonas", "Kaia", "Leon", "Mira", "Noah", "Olivia", "Pavel",
  "Rosa", "Samir", "Tessa", "Umar", "Vera", "Wren", "Yara", "Zane",
]

const LAST_NAMES = [
  "Almeida", "Baker", "Chen", "Dahl", "Ekwueme", "Fischer", "Garcia", "Hoffmann",
  "Ibrahim", "Jensen", "Kowalski", "Lindqvist", "Mendes", "Novak", "Okafor", "Petrova",
]

const DOMAINS = ["mail.example", "inbox.example", "post.example", "example.org"]

// Each doctor belongs to one department, so a visit's doctor and department
// never disagree; the list is what the schedule offers.
const DOCTORS: readonly (readonly [string, Appointment["department"]])[] = [
  ["Dr. Amara Osei", "Cardiology"],
  ["Dr. Tomas Lind", "Cardiology"],
  ["Dr. Priya Raman", "Neurology"],
  ["Dr. Elias Berg", "Neurology"],
  ["Dr. Hana Sato", "Oncology"],
  ["Dr. Marcus Reid", "Oncology"],
  ["Dr. Lucia Ferrer", "Pediatrics"],
  ["Dr. Kofi Mensah", "Pediatrics"],
  ["Dr. Ingrid Vos", "Orthopedics"],
  ["Dr. Rafael Duarte", "Orthopedics"],
]

// Three procedures a department books most, so the ranking on the dashboard
// has a head rather than twenty names with three visits each.
const PROCEDURES: Record<Appointment["department"], readonly string[]> = {
  Cardiology: ["Echocardiogram", "Stress test", "Holter fitting"],
  Neurology: ["EEG", "Nerve conduction study", "MRI review"],
  Oncology: ["Chemotherapy session", "Biopsy", "Port placement"],
  Pediatrics: ["Vaccination", "Growth assessment", "Hearing screen"],
  Orthopedics: ["Joint injection", "Cast fitting", "Physiotherapy review"],
}

const DURATIONS = [15, 30, 30, 45, 60, 90] as const

/**
 * Where a visit sits in time. The book runs six months back — enough for a
 * chart by month — and three weeks ahead. The two thirty-day windows behind
 * "now" are weighted close to each other, so a month-on-month delta reads
 * as growth rather than as a cliff, and today gets a few visits of its own so
 * a calendar opening on it has a list to show — three of them, brought forward
 * below, still ahead of "now" for the desk to check in.
 */
const WINDOW_MIX: readonly (readonly [[number, number], number])[] = [
  [[-180, -61], 0.24],
  [[-60, -31], 0.28],
  [[-30, -1], 0.22],
  [[0, 0], 0.04],
  [[1, 21], 0.22],
]

/** A clinic slot: a weekday between 08:00 and 16:45 UTC, on a quarter hour. */
function slotOn(rand: () => number, dayOffset: number): Date {
  const day = daysAhead(dayOffset)
  const base = Date.UTC(day.getUTCFullYear(), day.getUTCMonth(), day.getUTCDate())
  const hour = intBetween(rand, 8, 16)
  const quarter = intBetween(rand, 0, 3) * 15
  return new Date(base + hour * 3_600_000 + quarter * 60_000)
}

/** The last quarter hours of the reference day the desk can still fill: from 16:00 on. */
const LATE_FROM_MIN = 16 * 60
const QUARTER_MS = 15 * 60_000

/**
 * The end of the reference day, where a desk opening the book at 15:40 still
 * has patients to check in. The draw leaves nothing booked on it after then —
 * today's visits all fall in the morning — so the three visits nearest ahead
 * are brought forward onto it: the same patients, doctors, lengths and
 * procedures, only the day moved, each from 16:00 on a quarter hour and after
 * the one before it with the same doctor. They are still the first three rows
 * ahead of now, so no other row moves and no id changes.
 */
function bringForward(rows: Appointment[]): Appointment[] {
  const first = rows.findIndex((row) => row.at.getTime() > REFERENCE_DATE.getTime())
  if (first < 0) return rows
  const day = Date.UTC(REFERENCE_DATE.getUTCFullYear(), REFERENCE_DATE.getUTCMonth(), REFERENCE_DATE.getUTCDate())
  const freeFrom = new Map<string, number>()

  return rows.map((row, index) => {
    const slot = index - first
    if (slot < 0 || slot > 2) return row
    const earliest = day + (LATE_FROM_MIN + slot * 15) * 60_000
    const start = Math.ceil(Math.max(earliest, freeFrom.get(row.doctor) ?? 0) / QUARTER_MS) * QUARTER_MS
    freeFrom.set(row.doctor, start + row.durationMin * 60_000)
    return { ...row, at: new Date(start), status: "scheduled" as const }
  })
}

function generate(): Appointment[] {
  const rand = seeded("appointments")

  const drawn = Array.from({ length: COUNT }, (_, index) => {
    const [from, to] = pickWeighted(rand, WINDOW_MIX)
    let offset = intBetween(rand, from, to)
    // Clinics close at the weekend: nudge a Saturday or Sunday to Monday.
    const weekday = daysAhead(offset).getUTCDay()
    if (weekday === 6) offset += 2
    if (weekday === 0) offset += 1
    const at = slotOn(rand, offset)
    const past = at.getTime() <= REFERENCE_DATE.getTime()
    const today = daysAhead(offset).toISOString().slice(0, 10) === REFERENCE_DATE.toISOString().slice(0, 10)

    const [doctor, department] = pick(rand, DOCTORS)
    const status: Appointment["status"] = !past
      ? "scheduled"
      : today && chance(rand, 0.5)
        ? "checked_in"
        : chance(rand, 0.08)
          ? "cancelled"
          : "done"

    const name = `${pick(rand, FIRST_NAMES)} ${pick(rand, LAST_NAMES)}`

    return {
      id: rowId("apt", index + 1),
      patient: name,
      avatarUrl: avatarFor(name),
      email: emailFor(name, pick(rand, DOMAINS)),
      doctor,
      department,
      at,
      durationMin: pick(rand, DURATIONS),
      status,
      // Half the book is procedures; the rest are consultations.
      procedure: chance(rand, 0.5) ? pick(rand, PROCEDURES[department]) : undefined,
      isNewPatient: chance(rand, 0.22),
    }
  }).sort((a, b) => a.at.getTime() - b.at.getTime())
    .map((row, index) => ({ ...row, id: rowId("apt", index + 1) }))

  return bringForward(drawn)
}

/** The seeded book, oldest first. The repository below owns the rows the desk changes. */
export const APPOINTMENTS: Appointment[] = generate()

export const appointments = createRepository(APPOINTMENTS, {
  searchKeys: ["patient", "doctor", "email"],
  filterKeys: ["department", "status", "doctor"],
})

import { createRepository, dateBetween, daysAgo, intBetween, rowId, seeded, slugify } from "./core"

/** The six shelves the help centre is arranged on. */
export const ARTICLE_CATEGORIES = [
  "Getting started",
  "Billing",
  "Integrations",
  "Security",
  "Data & exports",
  "Troubleshooting",
] as const

export type ArticleCategory = (typeof ARTICLE_CATEGORIES)[number]

/** One help article: what it is called, where it is filed, and what it says. */
export type Article = {
  id: string
  /** From the title; the URL a help centre links each article at. */
  slug: string
  title: string
  category: ArticleCategory
  /** The line under the title in a list. */
  summary: string
  body: string
  updatedAt: Date
  minutesToRead: number
  /** Reads in the last 90 days, for ordering a "most read" list. */
  views: number
}

// The articles themselves, written out rather than generated: help text is the
// one thing a reader actually reads, and a sentence assembled from fragments
// reads like one. The generator below only decides when each was last touched
// and how often it has been opened.
const TOPICS: readonly { title: string; category: ArticleCategory; summary: string; body: string }[] = [
  {
    title: "Create your first workspace",
    category: "Getting started",
    summary: "Name a workspace, pick a region, and invite the people who will work in it.",
    body: "A workspace is the boundary everything else sits inside: members, data, billing and audit history all belong to exactly one. Choose the region closest to the people who will use it — the region fixes where rows are stored and cannot be changed afterwards. Once it exists, invite your team from Settings → Members; an invitation is good for fourteen days and can be resent or revoked at any point before it is accepted.",
  },
  {
    title: "Invite teammates and set their roles",
    category: "Getting started",
    summary: "The four roles, what each one may do, and how to change someone's later.",
    body: "Every member holds one of four roles. Owner is the single account that can delete the workspace or move billing; admin can do everything else, including managing members and API keys; member can read and write the data itself; viewer can read it and nothing more. Change a role from the members table — the change takes effect on that person's next request, and is written to the audit log with who made it.",
  },
  {
    title: "Import your existing data",
    category: "Getting started",
    summary: "Bring a CSV in, map its columns to fields, and check the preview before you commit.",
    body: "The importer reads a CSV with a header row and shows you the first five rows as it understood them. Columns are matched to fields by name where they line up, and anything it could not match is left for you to choose. Nothing is written until you confirm the preview, and a row that fails validation is reported with its line number rather than silently skipped.",
  },
  {
    title: "Set up your notification preferences",
    category: "Getting started",
    summary: "Choose which events reach you, and whether they arrive by email or in the app.",
    body: "Notifications are grouped by the thing they are about — deployments, billing, mentions, and weekly summaries. Each group can be switched on for email, for the in-app inbox, or for both. Preferences are per person, not per workspace, so the same choices follow you into every workspace you belong to.",
  },
  {
    title: "Understand your invoice",
    category: "Billing",
    summary: "What each line means, when it is charged, and how proration is worked out.",
    body: "An invoice covers one billing period and is issued on the first day of it. The subscription line is the plan's own price for the seats you held at the start of the period; usage lines are metered and billed a period in arrears. If you changed plans or seat count mid-period, the difference appears as a prorated line calculated to the day, not the hour.",
  },
  {
    title: "Change or cancel your plan",
    category: "Billing",
    summary: "Upgrades take effect immediately; downgrades wait for the period to end.",
    body: "An upgrade applies the moment you confirm it, and the remainder of the current period is prorated onto your next invoice. A downgrade is scheduled for the end of the period so you keep what you have already paid for. Cancelling behaves the same way: the workspace stays on its plan until the period ends, then moves to the free tier with its data intact and read-only where the free tier does not reach.",
  },
  {
    title: "Update your payment method",
    category: "Billing",
    summary: "Add a card, make it the default, and remove the one it replaced.",
    body: "Add the new card first from Billing → Payment methods, then mark it as the default; a workspace always keeps at least one card on file while it has an active subscription. Removing a card that is not the default is immediate. If a charge has already failed, adding a card does not retry it on its own — use Retry payment on the invoice itself.",
  },
  {
    title: "Add a VAT number and billing address",
    category: "Billing",
    summary: "Where tax details go, and when a change reaches the next invoice.",
    body: "Billing details live on the workspace, not on the person paying, so they survive a change of owner. A VAT number is validated against the registry for its country when you save it; an invalid one is rejected rather than stored. Details you change apply to the next invoice issued — an invoice already sent cannot be reissued with new tax details.",
  },
  {
    title: "Connect a chat workspace",
    category: "Integrations",
    summary: "Authorise the app, pick a default channel, and route events per project.",
    body: "Authorising the app installs it into the chat workspace you choose and posts nothing until you pick a default channel. Each project can then override that channel, which is how a noisy service ends up somewhere other than the room everyone reads. Disconnecting removes the app's token immediately; the messages it has already posted stay where they are.",
  },
  {
    title: "Create and rotate API keys",
    category: "Integrations",
    summary: "Scope a key to what it needs, and replace it without downtime.",
    body: "A key is shown once, at the moment it is created, and stored only as a hash afterwards — if you lose it, create another. Scope each key to the smallest set of permissions the integration needs. To rotate without downtime, create the replacement, deploy it, then revoke the old key once its last-used timestamp stops moving.",
  },
  {
    title: "Send events to a webhook",
    category: "Integrations",
    summary: "Register an endpoint, verify the signature, and read the delivery log.",
    body: "Register the endpoint and choose which event types it should receive. Every delivery carries a signature header computed from your endpoint's secret; verify it before you trust the payload. Failed deliveries are retried with exponential backoff for up to 24 hours, and every attempt — with its response code and body — is visible in the delivery log.",
  },
  {
    title: "Export to your data warehouse",
    category: "Integrations",
    summary: "Schedule a nightly sync into the warehouse your analysts already use.",
    body: "A warehouse sync writes one table per entity plus a manifest describing the run. Schedule it for a quiet hour in your own timezone; the first run is a full load and every run after it is incremental, keyed on the row's updated timestamp. A run that fails leaves the previous tables untouched, so a warehouse is never half-updated.",
  },
  {
    title: "Turn on two-factor authentication",
    category: "Security",
    summary: "Scan the setup code with an authenticator app, then confirm a six-digit code.",
    body: "Two-factor authentication asks for a code from your phone in addition to your password. Scan the setup code with any authenticator app, or type the secret in by hand if the camera is not available, then confirm the six digits it shows. Save your recovery codes somewhere other than the phone — they are the only way back in if you lose the device.",
  },
  {
    title: "Sign in with a passkey",
    category: "Security",
    summary: "What a passkey is, where it is stored, and how to add one to your account.",
    body: "A passkey replaces your password with a key pair your device holds. The private half never leaves the device and is unlocked by whatever already unlocks it — a fingerprint, a face, a PIN — so there is nothing to type and nothing a phishing page can capture. Add one from Settings → Security; you can hold several, one per device, and remove any of them without affecting the rest.",
  },
  {
    title: "Enforce single sign-on for your workspace",
    category: "Security",
    summary: "Point the workspace at your identity provider and require it for everyone.",
    body: "Single sign-on is configured per workspace against a SAML or OIDC provider. Test it with your own account before you enforce it: once enforcement is on, every member signs in through the provider and password sign-in stops working. The owner keeps a break-glass password login so a misconfigured provider cannot lock the workspace out entirely.",
  },
  {
    title: "Read the audit log",
    category: "Security",
    summary: "Who changed what, when, and from where — and how far back it goes.",
    body: "Every change to a member, a role, a key or a billing detail is written to the audit log with the actor, the resource, the fields that changed, and the address the request came from. Entries are immutable and retained for 90 days on Team and two years on Enterprise. Filter by actor or resource to narrow a search, and export the result as CSV for an auditor who cannot log in.",
  },
  {
    title: "Export a table as CSV",
    category: "Data & exports",
    summary: "Export what is on screen, filters and column choices included.",
    body: "An export takes the table exactly as you are looking at it: the same filters, the same sort, the same visible columns. Anything under fifty thousand rows downloads straight away; anything larger is prepared in the background and emailed to you as a link that expires after seven days. Dates are written in ISO 8601 and always in UTC.",
  },
  {
    title: "Schedule a recurring report",
    category: "Data & exports",
    summary: "Have the same view delivered by email every week or every month.",
    body: "Save a view first — its filters and columns are what the report will contain — then schedule it daily, weekly or monthly, and choose who receives it. Recipients do not need an account to open the attachment, so treat the schedule as a sharing decision. A scheduled report that errors twice in a row is paused and its owner told why.",
  },
  {
    title: "Request an export of your whole account",
    category: "Data & exports",
    summary: "One archive of everything the workspace holds, and how long it takes.",
    body: "An account export packages every entity the workspace holds as newline-delimited JSON, one file per entity, in a single archive. Only an owner can request one, and only one request runs at a time. Large workspaces take a few hours; you will get an email with a download link when it is ready, and the link is good for seven days.",
  },
  {
    title: "Delete data and understand retention",
    category: "Data & exports",
    summary: "What a delete removes now, what it removes later, and what it never removes.",
    body: "Deleting a row removes it from every view immediately and from backups within 35 days. Audit entries are the exception: they record that the deletion happened and are kept for the retention window of your plan. Deleting a workspace schedules the whole account for removal after 30 days, during which an owner can still restore it.",
  },
  {
    title: "A sign-in link says it has expired",
    category: "Troubleshooting",
    summary: "Why magic links expire, and what to do when yours already has.",
    body: "A sign-in link is good for fifteen minutes and for one use. A mail scanner that follows links before you do will spend it — which is why the second click reports an expired link even though you never used the first. Request a new one from the same page; if that keeps happening, ask your mail administrator to exclude our sending domain from link scanning.",
  },
  {
    title: "An import failed part way through",
    category: "Troubleshooting",
    summary: "How to read the error report, fix the file, and import the rest.",
    body: "An import is applied in batches, and a batch that fails is rolled back whole, so rows are never half-written. The error report names the line number and the field for every rejected row. Fix those lines in the original file, remove the lines that already imported, and run it again — repeated rows are matched on their external id and updated rather than duplicated.",
  },
  {
    title: "A webhook is not being delivered",
    category: "Troubleshooting",
    summary: "Work through the delivery log, the signature, and the response your endpoint sends.",
    body: "Start with the delivery log: it shows every attempt, the status code your endpoint returned, and the first kilobyte of its response. Anything other than a 2xx counts as a failure and is retried. The two common causes are a signature check comparing against the wrong secret after a rotation, and an endpoint that takes longer than ten seconds to answer — acknowledge first, then do the work.",
  },
  {
    title: "Charts show no data for a period",
    category: "Troubleshooting",
    summary: "Timezones, incomplete days, and filters that outlive the page you set them on.",
    body: "Three things usually explain an empty chart. The period may be measured in UTC while you are reading it in your own timezone, so the current day looks short. The most recent hour is still being aggregated and is deliberately left out. And a filter saved on a view stays on it — check the toolbar for a filter you set on a previous visit before concluding the data is missing.",
  },
]

function generate(): Article[] {
  const rand = seeded("articles")

  return TOPICS.map((topic, index) => ({
    id: rowId("art", index + 1),
    slug: slugify(topic.title),
    title: topic.title,
    category: topic.category,
    summary: topic.summary,
    body: topic.body,
    // Help text is revised, not written once: everything has been touched in
    // the last ten months, and nothing is stamped after "now".
    updatedAt: dateBetween(rand, daysAgo(300), daysAgo(2)),
    minutesToRead: intBetween(rand, 2, 8),
    views: intBetween(rand, 180, 9_400),
  }))
}

/** The seeded help centre. The repository below owns the rows a demo mutates. */
export const ARTICLES: Article[] = generate()

export const articles = createRepository(ARTICLES, {
  searchKeys: ["title", "summary", "category", "body"],
  filterKeys: ["category"],
})

import { REFERENCE_DATE, createRepository, dateBetween, daysAgo, intBetween, pick, pickWeighted, rowId, seeded, shuffle } from "./core"
import { MEMBERS } from "./members"

/** One line in the workspace's audit trail. */
export type AuditEvent = {
  id: string
  at: Date
  /** A Member id: whoever performed the action. */
  actor: string
  action: string
  resource: string
  resourceId: string
  ip: string
  diff?: { field: string; from: string; to: string }[]
}

const COUNT = 500

const RESOURCES = [
  "customer", "member", "invitation", "role", "api_key",
  "integration", "billing", "service", "deployment", "alert",
]

// A plausible-looking id for the log line — not asserted to resolve to a real
// row the way `actor` is; an audit trail routinely outlives the records it
// describes.
const RESOURCE_PREFIX: Record<string, string> = {
  customer: "cus",
  member: "mbr",
  invitation: "ivt",
  role: "rol",
  api_key: "key",
  integration: "itg",
  billing: "bil",
  service: "svc",
  deployment: "dpl",
  alert: "alr",
}

const ACTION_MIX: readonly (readonly [string, number])[] = [
  ["updated", 0.35],
  ["created", 0.25],
  ["deleted", 0.08],
  ["invited", 0.08],
  ["revoked", 0.06],
  ["enabled", 0.06],
  ["disabled", 0.06],
  ["exported", 0.06],
]

/** A field this kind of change might touch, and a few plausible values. */
const DIFF_FIELDS: { field: string; values: string[] }[] = [
  { field: "status", values: ["active", "suspended", "churned", "trial"] },
  { field: "role", values: ["member", "admin", "viewer", "owner"] },
  { field: "plan", values: ["free", "starter", "team", "enterprise"] },
  { field: "seats", values: ["5", "10", "25", "50"] },
  { field: "name", values: ["Untitled", "Renamed workspace", "Northwind", "Northwind Studio"] },
]

function buildDiff(rand: () => number): NonNullable<AuditEvent["diff"]> {
  const fields = shuffle(rand, DIFF_FIELDS).slice(0, intBetween(rand, 1, 2))
  return fields.map(({ field, values }) => {
    const [from, to] = shuffle(rand, values).slice(0, 2)
    return { field, from, to }
  })
}

function generate(): AuditEvent[] {
  const rand = seeded("auditEvents")
  const actors = MEMBERS.filter((member) => member.status === "active").map((member) => member.id)

  return Array.from({ length: COUNT }, (_, index) => {
    const resource = pick(rand, RESOURCES)
    const action = pickWeighted(rand, ACTION_MIX)

    return {
      id: rowId("aud", index + 1),
      at: dateBetween(rand, daysAgo(365), REFERENCE_DATE),
      actor: pick(rand, actors),
      action,
      resource,
      resourceId: rowId(RESOURCE_PREFIX[resource], intBetween(rand, 1, 200)),
      ip: `${intBetween(rand, 1, 255)}.${intBetween(rand, 0, 255)}.${intBetween(rand, 0, 255)}.${intBetween(rand, 1, 254)}`,
      diff: action === "updated" ? buildDiff(rand) : undefined,
    }
  })
}

/** The seeded audit trail. The repository below owns the rows a demo mutates. */
export const AUDIT_EVENTS: AuditEvent[] = generate()

export const auditEvents = createRepository(AUDIT_EVENTS, {
  searchKeys: ["action", "resource", "resourceId"],
  filterKeys: ["resource", "actor"],
})

import {
  REFERENCE_DATE,
  chance,
  createRepository,
  dateBetween,
  daysAgo,
  daysAhead,
  intBetween,
  pick,
  pickWeighted,
  rowId,
  seeded,
} from "./core"
import { avatarFor } from "./avatars"

/**
 * A room in the house. Not an entity of its own: a hotel's room list is a
 * fixed inventory rather than rows that come and go, so it is a constant here
 * and a booking points at one by id.
 */
export type Room = {
  id: string
  /** The number on the door. */
  number: string
  type: "standard" | "deluxe" | "suite"
  floor: number
  beds: number
  /** The rack rate in minor units — what the room goes for before any discount. */
  rackRateCents: number
}

const FLOOR_PLAN: readonly (readonly [Room["type"], number, number, number])[] = [
  // type, rooms per floor, beds, rack rate in cents
  ["standard", 6, 1, 189_00],
  ["deluxe", 4, 2, 279_00],
  ["suite", 2, 2, 449_00],
]

/** The house: three floors of twelve, standard through suite. */
export const ROOMS: readonly Room[] = [1, 2, 3].flatMap((floor) => {
  let door = 0
  return FLOOR_PLAN.flatMap(([type, count, beds, rackRateCents]) =>
    Array.from({ length: count }, () => {
      door += 1
      const number = `${floor}${String(door).padStart(2, "0")}`
      return { id: `room-${number}`, number, type, floor, beds, rackRateCents }
    })
  )
})

/** A stay: who, which room, which nights, and what it came to. */
export type Booking = {
  id: string
  /** The reference a guest quotes at the desk. */
  reference: string
  guestName: string
  /** A face for the guest — the kit's own avatar route for the name. */
  guestAvatar: string
  /** A Room id. */
  roomId: string
  status: "confirmed" | "checked_in" | "checked_out" | "cancelled" | "no_show"
  /** Midnight UTC on the arrival day. */
  checkIn: Date
  /** Midnight UTC on the departure day; the guest is not in the room that night. */
  checkOut: Date
  nights: number
  adults: number
  children: number
  /** What this stay actually pays per night, in minor units. */
  ratePerNightCents: number
  /** `nights * ratePerNightCents`, in minor units. */
  totalCents: number
  currency: "USD"
  /**
   * The channel it came through: the hotel's own desk and site, a travel
   * marketplace, a booking site, a corporate account or the door. Kinds of
   * channel, never the companies that run them.
   */
  source: "direct" | "marketplace" | "booking_site" | "corporate" | "walk_in"
  bookedAt: Date
}

// The window the book covers, in days either side of the reference date: six
// weeks of history for last night's occupancy, six weeks of forward book for a
// month of availability.
const OPEN = -40
const CLOSE = 42

const FIRST_NAMES = [
  "Amara", "Bruno", "Cecile", "Dimitri", "Elif", "Finn", "Greta", "Hassan",
  "Ingrid", "Jonas", "Kaori", "Lucia", "Mateo", "Nadia", "Oskar", "Petra",
  "Quinn", "Rosa", "Samir", "Tanya", "Ulrich", "Vera", "Wren", "Yusuf",
]

const LAST_NAMES = [
  "Adeyemi", "Bertrand", "Castellano", "Delacroix", "Eriksen", "Fontaine",
  "Grunewald", "Hoffmann", "Ivanova", "Janssen", "Kowalski", "Lindqvist",
  "Moretti", "Nakamura", "Oyelaran", "Petrov", "Ramirez", "Sorensen",
  "Tanaka", "Ueda", "Vasquez", "Weber", "Yilmaz", "Zielinski",
]

/**
 * The nights a room sits empty between two stays: mostly none at all, which is
 * what puts occupancy in the seventies rather than at half the house.
 */
const GAP_MIX: readonly (readonly [number, number])[] = [
  [0, 0.45],
  [1, 0.3],
  [2, 0.15],
  [3, 0.1],
]

/** How long a stay runs, weighted the way a city hotel's book actually falls. */
const NIGHTS_MIX: readonly (readonly [number, number])[] = [
  [1, 0.32],
  [2, 0.28],
  [3, 0.19],
  [4, 0.11],
  [5, 0.06],
  [7, 0.04],
]

const SOURCE_MIX: readonly (readonly [Booking["source"], number])[] = [
  ["direct", 0.31],
  ["marketplace", 0.27],
  ["booking_site", 0.18],
  ["corporate", 0.15],
  ["walk_in", 0.09],
]

/** What each channel costs, as a share off the rack rate the room asks. */
const CHANNEL_DISCOUNT: Record<Booking["source"], number> = {
  direct: 0,
  marketplace: 0.15,
  booking_site: 0.17,
  corporate: 0.22,
  walk_in: 0.05,
}

/** Midnight UTC on the day `date` falls on — a night is a calendar day. */
function utcDay(date: Date): Date {
  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()))
}

const TODAY = utcDay(REFERENCE_DATE)

const ROOM_BY_ID = new Map(ROOMS.map((room) => [room.id, room]))

/**
 * What a stay is, read off the calendar. A guest who left before today is
 * checked out; one who arrived earlier and has not left is in the house — due
 * out today included, because they are still in the room this morning; and one
 * arriving today or later is confirmed but not yet at the desk, which is what
 * makes an arrivals list something a front desk still has to work through. A
 * scattering of cancellations and no-shows sits over all of it.
 */
function statusFor(rand: () => number, checkIn: Date, checkOut: Date): Booking["status"] {
  if (chance(rand, 0.06)) return "cancelled"
  if (checkOut.getTime() < TODAY.getTime()) return chance(rand, 0.04) ? "no_show" : "checked_out"
  if (checkIn.getTime() >= TODAY.getTime()) return "confirmed"
  return "checked_in"
}

/**
 * The book, laid out room by room rather than booking by booking: each room is
 * filled from the start of the window with a stay, then a gap, then the next
 * stay, until the window runs out. Picking a room at random per booking would
 * put two guests in one room on the same night, and an in-house list that
 * names room 203 twice is not a hotel — it is a bug the picture hides.
 */
function generate(): Booking[] {
  const rand = seeded("bookings")

  const stays: { roomId: string; night: number; nights: number }[] = []
  for (const room of ROOMS) {
    // Each room opens a few days into the window, so the house does not turn
    // over all at once on the first morning.
    let night = OPEN + intBetween(rand, 0, 4)
    while (night <= CLOSE) {
      const nights = pickWeighted(rand, NIGHTS_MIX)
      stays.push({ roomId: room.id, night, nights })
      night += nights + pickWeighted(rand, GAP_MIX)
    }
  }
  // Ids run in arrival order, so bkg_0001 is the first guest through the door.
  stays.sort((a, b) => a.night - b.night || a.roomId.localeCompare(b.roomId))

  return stays.map((stay, index) => {
    const checkIn = utcDay(daysAhead(stay.night))
    const checkOut = daysAhead(stay.nights, checkIn)
    const room = ROOM_BY_ID.get(stay.roomId)!
    const source = pickWeighted(rand, SOURCE_MIX)
    const ratePerNightCents =
      Math.round((room.rackRateCents * (1 - CHANNEL_DISCOUNT[source])) / 100) * 100

    // Booked between six months out and the morning of arrival — a walk-in on
    // the day, a corporate block half a year ahead — but never later than
    // "now", because a stay still ahead of us was booked behind us.
    const bookedAt = dateBetween(
      rand,
      daysAgo(180, checkIn),
      new Date(Math.min(checkIn.getTime(), REFERENCE_DATE.getTime()))
    )

    const guestName = `${pick(rand, FIRST_NAMES)} ${pick(rand, LAST_NAMES)}`

    return {
      id: rowId("bkg", index + 1),
      reference: `NW-${String(index + 1).padStart(5, "0")}`,
      guestName,
      guestAvatar: avatarFor(guestName),
      roomId: room.id,
      status: statusFor(rand, checkIn, checkOut),
      checkIn,
      checkOut,
      nights: stay.nights,
      adults: intBetween(rand, 1, 2),
      children: chance(rand, 0.22) ? intBetween(rand, 1, 2) : 0,
      ratePerNightCents,
      totalCents: stay.nights * ratePerNightCents,
      currency: "USD" as const,
      source,
      bookedAt,
    }
  })
}

/** The seeded book. The repository below owns the rows the desk changes. */
export const BOOKINGS: Booking[] = generate()

export const bookings = createRepository(BOOKINGS, {
  searchKeys: ["guestName", "reference"],
  filterKeys: ["status", "source", "roomId"],
})

import {
  REFERENCE_DATE,
  chance,
  createRepository,
  dateBetween,
  daysAgo,
  intBetween,
  rowId,
  seeded,
  shuffle,
} from "./core"

/** A marketing push on one channel, tracked from spend through to conversions. */
export type Campaign = {
  id: string
  name: string
  channel: "search" | "social" | "email" | "referral" | "organic"
  /** Spend in minor units — cents, not dollars. */
  spendCents: number
  clicks: number
  conversions: number
  startedAt: Date
  endedAt?: Date
  status: "active" | "paused" | "completed"
}

const COUNT = 24

// A hand-written slate, each name already paired with the channel it runs on.
// A campaign is named for its idea, never for a platform someone else owns:
// the channel already says where it runs.
const CATALOG: readonly (readonly [string, Campaign["channel"]])[] = [
  ["Search — Brand Terms", "search"],
  ["Search — Competitor Terms", "search"],
  ["Search — Product Launch", "search"],
  ["Search — Holiday Push", "search"],
  ["Search — Retargeting", "search"],
  ["Founder Thought Leadership", "social"],
  ["Brand Awareness Series", "social"],
  ["Cart Abandoner Retargeting", "social"],
  ["Short-Form Product Teasers", "social"],
  ["Launch Day Announcement", "social"],
  ["Welcome Series Revamp", "email"],
  ["Quarterly Newsletter", "email"],
  ["Win-Back Campaign", "email"],
  ["Feature Announcement Blast", "email"],
  ["Customer Advocacy Digest", "email"],
  ["Partner Referral Program", "referral"],
  ["Customer Referral Bonus", "referral"],
  ["Affiliate Launch Push", "referral"],
  ["Reseller Incentive Drive", "referral"],
  ["Community Ambassador Program", "referral"],
  ["SEO Content Overhaul", "organic"],
  ["Blog Editorial Calendar", "organic"],
  ["Guest Post Outreach", "organic"],
  ["Documentation Refresh", "organic"],
]

const SPEND_RANGE_CENTS: Record<Campaign["channel"], readonly [number, number]> = {
  search: [200_000, 2_000_000],
  social: [100_000, 1_500_000],
  email: [5_000, 50_000],
  referral: [10_000, 200_000],
  // Organic is editorial time, not ad spend — a small tooling cost at most.
  organic: [0, 20_000],
}

function generate(): Campaign[] {
  const rand = seeded("campaigns")
  // The slate is already distinct; shuffle only so id order does not mirror
  // the channel grouping it was written in.
  const slate = shuffle(rand, CATALOG).slice(0, COUNT)

  return slate.map(([name, channel], index) => {
    const [minSpend, maxSpend] = SPEND_RANGE_CENTS[channel]
    const clicks = intBetween(rand, 200, 40_000)
    // Up to an 8% click-to-conversion rate.
    const conversions = intBetween(rand, 0, Math.floor(clicks * 0.08))
    const startedAt = dateBetween(rand, daysAgo(365), daysAgo(1))
    const hasEnded = chance(rand, 0.6)
    // A live campaign is occasionally paused rather than actively running.
    const status: Campaign["status"] = hasEnded ? "completed" : chance(rand, 0.15) ? "paused" : "active"

    return {
      id: rowId("cmp", index + 1),
      name,
      channel,
      spendCents: intBetween(rand, minSpend, maxSpend),
      clicks,
      conversions,
      startedAt,
      ...(hasEnded ? { endedAt: dateBetween(rand, startedAt, REFERENCE_DATE) } : {}),
      status,
    }
  })
}

/** The seeded campaign slate. The repository below owns the rows a demo mutates. */
export const CAMPAIGNS: Campaign[] = generate()

export const campaigns = createRepository(CAMPAIGNS, {
  searchKeys: ["name"],
  filterKeys: ["channel", "status"],
})

import {
  chance,
  createRepository,
  dateBetween,
  daysAgo,
  intBetween,
  rowId,
  seeded,
  shuffle,
} from "./core"
import { MEMBERS } from "./members"

/**
 * A conversation in the chat app: a direct message with one teammate, or a
 * named group. The signed-in member — `MEMBERS[0]`, the workspace owner — is
 * in every one of them, which is what makes the list theirs.
 */
export type Chat = {
  id: string
  kind: "dm" | "group"
  /** A group's own name; for a dm, the other member's name. */
  name: string
  /** Member ids, the signed-in member included. */
  memberIds: string[]
  /** Messages at the end of the thread the reader has not opened yet. */
  unread: number
  lastMessageAt: Date
  muted: boolean
}

const DM_COUNT = 9

const GROUP_NAMES = ["Design team", "Launch week", "Platform on-call", "Weekend trip", "Book club"]

function generate(): Chat[] {
  const rand = seeded("chats")
  const me = MEMBERS[0]
  // Only people still in the workspace write, and nobody chats with themselves.
  const others = MEMBERS.filter((member) => member.status === "active" && member.id !== me.id)
  const partners = shuffle(rand, others).slice(0, DM_COUNT)

  const dms: Chat[] = partners.map((partner, index) => ({
    id: rowId("cht", index + 1),
    kind: "dm",
    name: partner.name,
    memberIds: [me.id, partner.id],
    unread: chance(rand, 0.3) ? intBetween(rand, 1, 5) : 0,
    // Most threads moved this week; a couple went quiet a fortnight ago.
    lastMessageAt: dateBetween(rand, daysAgo(chance(rand, 0.75) ? 6 : 16), daysAgo(1 / 96)),
    muted: chance(rand, 0.1),
  }))

  const groups: Chat[] = GROUP_NAMES.map((name, index) => {
    const size = intBetween(rand, 3, 5)
    return {
      id: rowId("cht", DM_COUNT + index + 1),
      kind: "group",
      name,
      memberIds: [me.id, ...shuffle(rand, others).slice(0, size - 1).map((member) => member.id)],
      unread: chance(rand, 0.4) ? intBetween(rand, 1, 8) : 0,
      lastMessageAt: dateBetween(rand, daysAgo(chance(rand, 0.75) ? 6 : 16), daysAgo(1 / 48)),
      // A busy group is the one a reader mutes.
      muted: chance(rand, 0.4),
    }
  })

  return [...dms, ...groups]
}

/** The seeded chats. The repository below owns the rows the app opens and answers. */
export const CHATS: Chat[] = generate()

export const chats = createRepository(CHATS, {
  searchKeys: ["name"],
  filterKeys: ["kind", "muted"],
})