import rawBoard from "../public/data/board.json";
import rawMembers from "../public/data/members.json";
import type { BoardMeta, BoardState, CardData, Member, Priority } from "./types";

interface RawChecklistItem {
  id: string;
  text: string;
  done: boolean;
}

interface RawCard {
  id: string;
  title: string;
  description: string;
  assignee: string | null;
  labels: string[];
  priority: string;
  due: string | null;
  checklist: RawChecklistItem[];
}

interface RawColumn {
  id: string;
  title: string;
  wip_limit: number | null;
  card_ids: string[];
}

interface RawBoard extends Omit<BoardMeta, "priorities"> {
  priorities: string[];
  columns: RawColumn[];
  cards: RawCard[];
}

export const bundledMeta = rawBoard as unknown as RawBoard;
export const bundledMembers = (rawMembers as { members: Member[] }).members;

export function buildMeta(raw: unknown): BoardMeta {
  const source = raw as RawBoard;
  return {
    product: String(source.product ?? "Boardly"),
    workspace: String(source.workspace ?? "Harbor Studio"),
    board: String(source.board ?? "Website Relaunch"),
    today: String(source.today ?? "2026-10-14"),
    fictional_notice: String(
      source.fictional_notice ?? "Boardly is a fictional product created for UIBenchmark.",
    ),
    labels: Array.isArray(source.labels) ? source.labels.map((l) => ({ id: l.id, name: l.name })) : [],
    priorities: Array.isArray(source.priorities)
      ? (source.priorities as Priority[])
      : (["low", "medium", "high", "urgent"] as Priority[]),
  };
}

export function buildInitialState(raw: unknown = rawBoard): BoardState {
  const source = raw as RawBoard;
  const cards: Record<string, CardData> = {};
  for (const card of source.cards ?? []) {
    cards[card.id] = {
      id: card.id,
      title: card.title,
      description: card.description ?? "",
      assignee: card.assignee ?? null,
      labels: [...(card.labels ?? [])],
      priority: (card.priority as Priority) ?? "medium",
      due: card.due ?? null,
      checklist: (card.checklist ?? []).map((item) => ({
        id: item.id,
        text: item.text,
        done: Boolean(item.done),
      })),
    };
  }
  return {
    columns: (source.columns ?? []).map((column) => ({
      id: column.id,
      title: column.title,
      wip_limit: column.wip_limit ?? null,
      card_ids: [...column.card_ids].filter((id) => Boolean(cards[id])),
    })),
    cards,
  };
}

export function buildMembers(raw: unknown = rawMembers): Member[] {
  const source = raw as { members?: Member[] };
  if (!source || !Array.isArray(source.members)) return bundledMembers;
  return source.members.map((member) => ({
    id: member.id,
    name: member.name,
    role: member.role,
  }));
}

export function parseStoredBoard(raw: string | null): BoardState | null {
  if (!raw) return null;
  try {
    const parsed = JSON.parse(raw) as BoardState;
    if (!parsed || !Array.isArray(parsed.columns) || typeof parsed.cards !== "object" || !parsed.cards) {
      return null;
    }
    for (const column of parsed.columns) {
      if (typeof column.id !== "string" || !Array.isArray(column.card_ids)) return null;
    }
    const columns = parsed.columns.map((column) => ({
      id: column.id,
      title: String(column.title ?? column.id),
      wip_limit: typeof column.wip_limit === "number" ? column.wip_limit : null,
      card_ids: column.card_ids.filter((id) => Boolean(parsed.cards[id])),
    }));
    return { columns, cards: parsed.cards };
  } catch {
    return null;
  }
}