import { oc as ocBase } from "@orpc/contract";
import * as v from "valibot";
import { ProcessDefinitionSchema } from "../lazy-process.ts";
import { RestartingProcessStateSchema } from "../restarting-process.ts";
import { CronProcessStateSchema } from "../cron-process.ts";
import { TaskStateSchema } from "../task-list.ts";

// Re-export schemas for use in other modules
export { ProcessDefinitionSchema } from "../lazy-process.ts";
export { RestartingProcessStateSchema } from "../restarting-process.ts";
export { CronProcessStateSchema } from "../cron-process.ts";
export { TaskStateSchema } from "../task-list.ts";

const oc = ocBase.$input(v.void());

// Resource target (name or index)
const ResourceTarget = v.union([v.string(), v.number()]);

// Manager state schema
export const ManagerStateSchema = v.picklist([
  "idle",
  "initializing",
  "running",
  "stopping",
  "stopped",
]);

export type ManagerState = v.InferOutput<typeof ManagerStateSchema>;

// Manager status response
export const ManagerStatusSchema = v.object({
  state: ManagerStateSchema,
  processCount: v.number(),
  cronCount: v.number(),
  taskCount: v.number(),
});

export type ManagerStatus = v.InferOutput<typeof ManagerStatusSchema>;

// API response schemas
export const RestartingProcessInfoSchema = v.object({
  name: v.string(),
  state: RestartingProcessStateSchema,
  restarts: v.number(),
});

export type RestartingProcessInfo = v.InferOutput<typeof RestartingProcessInfoSchema>;

export const CronProcessInfoSchema = v.object({
  name: v.string(),
  state: CronProcessStateSchema,
  runCount: v.number(),
  failCount: v.number(),
  nextRun: v.nullable(v.string()), // ISO date string
});

export type CronProcessInfo = v.InferOutput<typeof CronProcessInfoSchema>;

export const TaskEntryInfoSchema = v.object({
  id: v.string(),
  state: TaskStateSchema,
  processNames: v.array(v.string()),
});

export type TaskEntryInfo = v.InferOutput<typeof TaskEntryInfoSchema>;

// API contract
export const manager = {
  status: oc.output(ManagerStatusSchema),
};

export const processes = {
  get: oc.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
  list: oc.output(v.array(RestartingProcessInfoSchema)),
  add: oc
    .input(v.object({ name: v.string(), definition: ProcessDefinitionSchema }))
    .output(RestartingProcessInfoSchema),
  start: oc.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
  stop: oc.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
  restart: oc
    .input(v.object({ target: ResourceTarget, force: v.optional(v.boolean()) }))
    .output(RestartingProcessInfoSchema),
  reload: oc
    .input(
      v.object({
        target: ResourceTarget,
        definition: ProcessDefinitionSchema,
        restartImmediately: v.optional(v.boolean()),
      }),
    )
    .output(RestartingProcessInfoSchema),
  remove: oc.input(v.object({ target: ResourceTarget })).output(v.object({ success: v.boolean() })),
};

export const tasks = {
  get: oc.input(v.object({ target: ResourceTarget })).output(TaskEntryInfoSchema),
  list: oc.output(v.array(TaskEntryInfoSchema)),
  add: oc
    .input(v.object({ name: v.string(), definition: ProcessDefinitionSchema }))
    .output(TaskEntryInfoSchema),
  remove: oc.input(v.object({ target: ResourceTarget })).output(TaskEntryInfoSchema),
};

export const crons = {
  get: oc.input(v.object({ target: ResourceTarget })).output(CronProcessInfoSchema),
  list: oc.output(v.array(CronProcessInfoSchema)),
  trigger: oc.input(v.object({ target: ResourceTarget })).output(CronProcessInfoSchema),
  start: oc.input(v.object({ target: ResourceTarget })).output(CronProcessInfoSchema),
  stop: oc.input(v.object({ target: ResourceTarget })).output(CronProcessInfoSchema),
};

export const api = {
  manager,
  processes,
  tasks,
  crons,
};