import { create } from "zustand";
import { persist } from "zustand/middleware";
import type { Organization, Task, Worker } from "@/lib/types";

interface AppState {
  currentOrganization: Organization | null;
  selectedTask: Task | null;
  workers: Worker[];
  organizations: Organization[];
  isLoading: boolean;
  error: string | null;
}

interface AppActions {
  setCurrentOrganization: (org: Organization | null) => void;
  setSelectedTask: (task: Task | null) => void;
  setWorkers: (workers: Worker[]) => void;
  addWorker: (worker: Worker) => void;
  updateWorker: (workerId: string, updates: Partial<Worker>) => void;
  removeWorker: (workerId: string) => void;
  setOrganizations: (orgs: Organization[]) => void;
  addOrganization: (org: Organization) => void;
  updateOrganization: (orgId: string, updates: Partial<Organization>) => void;
  removeOrganization: (orgId: string) => void;
  setLoading: (loading: boolean) => void;
  setError: (error: string | null) => void;
  clearError: () => void;
}

export const useAppStore = create<AppState & AppActions>()(
  persist(
    (set) => ({
      currentOrganization: null,
      selectedTask: null,
      workers: [],
      organizations: [],
      isLoading: false,
      error: null,

      setCurrentOrganization: (org) => set({ currentOrganization: org }),

      setSelectedTask: (task) => set({ selectedTask: task }),

      setWorkers: (workers) => set({ workers }),

      addWorker: (worker) =>
        set((state) => ({ workers: [...state.workers, worker] })),

      updateWorker: (workerId, updates) =>
        set((state) => ({
          workers: state.workers.map((w) =>
            w.id === workerId ? { ...w, ...updates } : w
          ),
        })),

      removeWorker: (workerId) =>
        set((state) => ({
          workers: state.workers.filter((w) => w.id !== workerId),
        })),

      setOrganizations: (orgs) => set({ organizations: orgs }),

      addOrganization: (org) =>
        set((state) => ({ organizations: [...state.organizations, org] })),

      updateOrganization: (orgId, updates) =>
        set((state) => ({
          organizations: state.organizations.map((o) =>
            o.id === orgId ? { ...o, ...updates } : o
          ),
        })),

      removeOrganization: (orgId) =>
        set((state) => ({
          organizations: state.organizations.filter((o) => o.id !== orgId),
        })),

      setLoading: (loading) => set({ isLoading: loading }),

      setError: (error) => set({ error }),

      clearError: () => set({ error: null }),
    }),
    {
      name: "app-storage",
      partialize: (state) => ({
        currentOrganization: state.currentOrganization,
        organizations: state.organizations,
      }),
    }
  )
);