import { create } from "zustand"
import type { TemplateEntry, JobRun } from "../types/api"

function safeGetItem(key: string, fallback: string): string {
  try {
    return localStorage.getItem(key) || fallback
  } catch {
    return fallback
  }
}

function safeSetItem(key: string, value: string) {
  try {
    localStorage.setItem(key, value)
  } catch {
    // ignore
  }
}

export interface ApiStore {
  serverUrl: string
  setServerUrl: (url: string) => void

  templates: TemplateEntry[]
  addTemplate: (t: TemplateEntry) => void
  removeTemplate: (id: string) => void
  loadTemplates: (list: TemplateEntry[]) => void

  templateDir: string
  setTemplateDir: (dir: string) => void

  runs: JobRun[]
  addRun: (run: JobRun) => void
  updateRun: (id: string, patch: Partial<JobRun> | ((run: JobRun) => Partial<JobRun>)) => void
  removeRun: (id: string) => void
  loadRuns: (list: JobRun[]) => void

  activeRunId: string | null
  setActiveRunId: (id: string | null) => void
}

export const useApiStore = create<ApiStore>((set, get) => ({
  serverUrl: safeGetItem("omr_server_url", "http://localhost:8000"),
  setServerUrl: (url) => {
    safeSetItem("omr_server_url", url)
    set({ serverUrl: url })
  },

  templates: [],
  addTemplate: (t) => set((s) => ({ templates: [...s.templates, t] })),
  removeTemplate: (id) => set((s) => ({ templates: s.templates.filter((t) => t.id !== id) })),
  loadTemplates: (list) => set({ templates: list }),

  templateDir: safeGetItem("omr_template_dir", ""),
  setTemplateDir: (dir) => {
    safeSetItem("omr_template_dir", dir)
    set({ templateDir: dir })
  },

  runs: [],
  addRun: (run) => set((s) => ({ runs: [...s.runs, run], activeRunId: run.id })),
  updateRun: (id, patch) =>
    set((s) => {
      const run = s.runs.find((r) => r.id === id)
      if (!run) return {}
      const next = typeof patch === "function" ? (patch as (run: JobRun) => Partial<JobRun>)(run) : patch
      return {
        runs: s.runs.map((r) => (r.id === id ? { ...r, ...next } : r)),
      }
    }),
  removeRun: (id) => set((s) => ({ runs: s.runs.filter((r) => r.id !== id) })),
  loadRuns: (list) => set({ runs: list }),

  activeRunId: null,
  setActiveRunId: (id) => set({ activeRunId: id }),
}))