import { create } from 'zustand';
import { IAsset, IProject } from '../types';
import { dataService } from '../services/dataService';

// LocalStorage key for caching selected project
const SELECTED_PROJECT_CACHE_KEY = 'selectedProjectId';

// Helper function to get cached project ID from localStorage
const getCachedProjectId = (): string => {
  try {
    const cached = localStorage.getItem(SELECTED_PROJECT_CACHE_KEY);
    return cached || '';
  } catch (error) {
    console.warn('Failed to read from localStorage:', error);
    return '';
  }
};

// Helper function to save project ID to localStorage
const saveProjectIdToCache = (projectId: string): void => {
  try {
    localStorage.setItem(SELECTED_PROJECT_CACHE_KEY, projectId);
  } catch (error) {
    console.warn('Failed to save to localStorage:', error);
  }
};

interface AssetState {
  assets: IAsset[];
  projects: IProject[];
  selectedProjectId: string;
  isLoading: boolean;
  error: string | null;

  fetchProjects: () => Promise<void>;
  setSelectedProjectId: (projectId: string) => void;
  fetchAssets: (projectId: string) => Promise<void>;
  addAsset: (asset: IAsset) => Promise<void>;
  updateAsset: (asset: IAsset) => Promise<void>;
  deleteAsset: (assetId: string) => Promise<void>;
}

export const useAssetStore = create<AssetState>((set, get) => ({
  assets: [],
  projects: [],
  selectedProjectId: getCachedProjectId(),
  isLoading: false,
  error: null,

  fetchProjects: async () => {
    set({ isLoading: true, error: null });
    try {
      const projects = await dataService.getProjects();
      set({ projects, isLoading: false });

      const currentSelectedId = get().selectedProjectId;
      const cachedProjectId = getCachedProjectId();

      // Check if cached project ID exists in the projects list
      const cachedProjectExists = cachedProjectId && projects.some(p => p._id === cachedProjectId);

      if (projects.length > 0) {
        let projectIdToSelect = currentSelectedId;

        // If we have a cached project ID and it exists in the list, use it
        if (cachedProjectExists) {
          projectIdToSelect = cachedProjectId;
        }
        // If no valid selection, use the first project
        else if (!currentSelectedId || !projects.some(p => p._id === currentSelectedId)) {
          projectIdToSelect = projects[0]._id;
          saveProjectIdToCache(projectIdToSelect);
        }

        set({ selectedProjectId: projectIdToSelect });
        get().fetchAssets(projectIdToSelect);
      }
    } catch (err: any) {
      set({ error: err.message, isLoading: false });
    }
  },

  setSelectedProjectId: (projectId) => {
    set({ selectedProjectId: projectId });
    saveProjectIdToCache(projectId); // Save to localStorage when project is selected
    get().fetchAssets(projectId);
  },

  fetchAssets: async (projectId) => {
    set({ isLoading: true, error: null });
    try {
      const assets = await dataService.getAssets(projectId);
      set({ assets, isLoading: false });
    } catch (err: any) {
      set({ error: err.message, isLoading: false });
    }
  },

  addAsset: async (asset) => {
    set({ isLoading: true });
    try {
      await dataService.createAsset(asset);
      // Safely handle if projectId is an object (populated) or string
      const pId = typeof asset.projectId === 'object' && (asset.projectId as any)._id
        ? (asset.projectId as any)._id
        : asset.projectId;

      await get().fetchAssets(String(pId));
    } catch (err: any) {
      set({ error: err.message, isLoading: false });
    }
  },

  updateAsset: async (asset) => {
    set({ isLoading: true });
    try {
      await dataService.updateAsset(asset);
      // Safely handle if projectId is an object (populated) or string
      const pId = typeof asset.projectId === 'object' && (asset.projectId as any)._id
        ? (asset.projectId as any)._id
        : asset.projectId;

      await get().fetchAssets(String(pId));
    } catch (err: any) {
      set({ error: err.message, isLoading: false });
    }
  },

  deleteAsset: async (assetId) => {
    set({ isLoading: true });
    try {
      await dataService.deleteAsset(assetId);
      // Optimistic update or refetch
      const currentProjectId = get().selectedProjectId;
      if (currentProjectId) await get().fetchAssets(currentProjectId);
    } catch (err: any) {
      set({ error: err.message, isLoading: false });
    }
  }
}));
// Legacy hook for compatibility if components use sites/selectedSiteId
export const useAssetStoreLegacy = () => {
  const store = useAssetStore();
  return {
    ...store,
    sites: store.projects,
    selectedSiteId: store.selectedProjectId,
    setSelectedSiteId: store.setSelectedProjectId,
    fetchSites: store.fetchProjects
  };
}