import { ORPCError } from "@orpc/server";
import type { JobPublisher } from "@rakazo/adapter-kit";
import { getCoachRhythm, setCoachRhythm } from "@rakazo/adapters";
import type {
  Actor,
  CheckIn,
  CoachRhythm,
  CoachToday,
  Goal,
  Habit,
  LogCheckIn,
} from "@rakazo/contracts";
import type { CheckInFilter, GoalPatch, HabitPatch, PrismaClient } from "@rakazo/db";
import {
  CoachNotFoundError,
  createGoal,
  createHabit,
  InvalidCoachInputError,
  listCheckIns,
  listGoals,
  listHabits,
  loadCoachToday,
  logCheckIn,
  removeGoal,
  removeHabit,
  updateGoal,
  updateHabit,
} from "@rakazo/db";

export interface CoachDeps {
  prisma: PrismaClient;
  jobs: JobPublisher;
}

/** Another user's ids read as missing, so a caller cannot probe them. */
async function mapErrors<T>(work: () => Promise<T>): Promise<T> {
  try {
    return await work();
  } catch (error) {
    if (error instanceof CoachNotFoundError) {
      throw new ORPCError("NOT_FOUND", { message: error.message });
    }
    if (error instanceof InvalidCoachInputError) {
      throw new ORPCError("BAD_REQUEST", { message: error.message });
    }
    throw error;
  }
}

/** Coach procedures for the signed-in user only; nothing here is space-scoped. */
export function createCoachService(deps: CoachDeps) {
  const { prisma } = deps;
  return {
    today: (actor: Actor): Promise<CoachToday> => loadCoachToday(prisma, actor.userId),

    listGoals: (actor: Actor, input: { status?: Goal["status"] }) =>
      listGoals(prisma, actor.userId, input),
    createGoal: (
      actor: Actor,
      input: {
        title: string;
        detail?: string;
        targetDate?: string | null;
        spaceId?: string | null;
      },
    ) => mapErrors(() => createGoal(prisma, actor.userId, { ...input, source: "user" })),
    updateGoal: (actor: Actor, { goalId, ...patch }: GoalPatch & { goalId: string }) =>
      mapErrors(() => updateGoal(prisma, actor.userId, goalId, patch)),
    removeGoal: async (actor: Actor, input: { goalId: string }) => {
      await mapErrors(() => removeGoal(prisma, actor.userId, input.goalId));
      return { ok: true as const };
    },

    listHabits: (actor: Actor, input: { includeInactive?: boolean }): Promise<Habit[]> =>
      listHabits(prisma, actor.userId, input),
    createHabit: (
      actor: Actor,
      input: { title: string; cadence: Habit["cadence"]; goalId?: string | null },
    ) => mapErrors(() => createHabit(prisma, actor.userId, { ...input, source: "user" })),
    updateHabit: (actor: Actor, { habitId, ...patch }: HabitPatch & { habitId: string }) =>
      mapErrors(() => updateHabit(prisma, actor.userId, habitId, patch)),
    removeHabit: async (actor: Actor, input: { habitId: string }) => {
      await mapErrors(() => removeHabit(prisma, actor.userId, input.habitId));
      return { ok: true as const };
    },

    logCheckIn: (actor: Actor, input: LogCheckIn): Promise<CheckIn> =>
      mapErrors(() => logCheckIn(prisma, actor.userId, input)),
    listCheckIns: (actor: Actor, input: CheckInFilter) =>
      mapErrors(() => listCheckIns(prisma, actor.userId, input)),

    getRhythm: (actor: Actor): Promise<CoachRhythm> => getCoachRhythm(prisma, actor.userId),
    setRhythm: (actor: Actor, rhythm: CoachRhythm): Promise<CoachRhythm> =>
      setCoachRhythm(deps, { userId: actor.userId, rhythm }),
  };
}