import { create } from 'zustand';
import type { ServiceMap, ServiceMapSummary } from '../types';
import { apiClient } from '../api/client';

const LAST_MAP_KEY = 'rackmapper:lastMapId';

function saveLastMapId(id: string | null) {
  if (id) localStorage.setItem(LAST_MAP_KEY, id);
  else localStorage.removeItem(LAST_MAP_KEY);
}

function getLastMapId(): string | null {
  return localStorage.getItem(LAST_MAP_KEY);
}

interface MapState {
  maps: ServiceMapSummary[];
  activeMap: ServiceMap | null;
  loading: boolean;
  fetchMaps: () => Promise<void>;
  loadMap: (id: string) => Promise<void>;
  createMap: (name: string, description?: string) => Promise<ServiceMap>;
  deleteMap: (id: string) => Promise<void>;
  setActiveMap: (map: ServiceMap | null) => void;
}

export const useMapStore = create<MapState>((set, get) => ({
  maps: [],
  activeMap: null,
  loading: false,

  fetchMaps: async () => {
    set({ loading: true });
    try {
      const maps = await apiClient.maps.list();
      set({ maps, loading: false });

      // Auto-restore the last active map after loading the list
      const lastId = getLastMapId();
      if (lastId && maps.some((m) => m.id === lastId)) {
        await get().loadMap(lastId);
      } else if (maps.length === 1) {
        // Convenience: auto-load if there's only one map
        await get().loadMap(maps[0].id);
      }
    } catch {
      set({ loading: false });
      throw new Error('Failed to load maps');
    }
  },

  loadMap: async (id) => {
    set({ loading: true });
    try {
      const map = await apiClient.maps.get(id);
      saveLastMapId(id);
      set({ activeMap: map, loading: false });
    } catch {
      set({ loading: false });
      throw new Error('Failed to load map');
    }
  },

  createMap: async (name, description) => {
    const map = await apiClient.maps.create({ name, description });
    set((s) => ({
      maps: [
        { id: map.id, name: map.name, description: map.description, createdAt: map.createdAt, updatedAt: map.updatedAt },
        ...s.maps,
      ],
    }));
    return map;
  },

  deleteMap: async (id) => {
    await apiClient.maps.delete(id);
    if (getLastMapId() === id) saveLastMapId(null);
    set((s) => ({
      maps: s.maps.filter((m) => m.id !== id),
      activeMap: s.activeMap?.id === id ? null : s.activeMap,
    }));
  },

  setActiveMap: (map) => {
    saveLastMapId(map?.id ?? null);
    set({ activeMap: map });
  },
}));