import { Failure } from "../async-op.js";
import type { FailurePayload } from "../types.ts";
import type { SyncedItem } from "./types.ts";

export type UserGameDataShape = Record<
  string,
  Record<
    string,
    (
      | { id: string; name: string; updatedTs: number }
      | { id: string; name: string; updatedTs: number; deleted: boolean }
    )[]
  >
>;

/**
 * Flattens the UserGameData structure to a flat SyncedItem[].
 */
export function toSyncedItems(data: UserGameDataShape) {
  return Object.values(data).flatMap((groups) => {
    return Object.values(groups).flatMap((items) => {
      return items.map((item): SyncedItem => {
        if (!("deleted" in item)) {
          return {
            id: item.id,
            name: item.id,
            deleted: false,
            updatedTs: item.updatedTs,
          };
        }

        return {
          id: item.id,
          name: item.name,
          deleted: item.deleted,
          updatedTs: item.updatedTs,
        };
      });
    });
  });
}

export function assertNonNullish<T>(
  value: T,
  message: string,
): asserts value is NonNullable<T> {
  if (value == null) {
    throw new Error(message);
  }
}

function isFailurePayload(
  error: unknown,
): error is { cause: Failure<FailurePayload> } {
  return error instanceof Error && error.cause instanceof Failure;
}

export function caughtToResult(error: unknown): Failure<FailurePayload> {
  if (isFailurePayload(error)) {
    return error.cause;
  }

  return new Failure<FailurePayload>({ type: "UNKNOWN_ERROR" });
}