import { writable, get } from 'svelte/store';
import { browser } from '$app/environment';

export interface SelectedCampaignState {
  id: string;
  name: string;
  budget?: number;
  budgetUsed: number;
  screensCount: number;
  adName: string | null;
  adId: string | null;
  startDate?: string;
  endDate?: string;
  status?: string;
}

const STORE_KEY_PREFIX = 'neoad_selected_campaign_';

function getStorageKey(userId?: string): string {
  return userId ? `${STORE_KEY_PREFIX}${userId}` : 'neoad_selected_campaign_state';
}

function createSelectedCampaignStore() {
  const { subscribe, set, update } = writable<SelectedCampaignState | null>(null);
  
  // Track the current user ID for scoped persistence
  let currentUserId: string | undefined;

  return {
    subscribe,
    set: (campaign: SelectedCampaignState | null) => {
      set(campaign);
      if (browser) {
        const key = getStorageKey(currentUserId);
        if (campaign) {
          // Never cache budget — it's always loaded fresh from API or $effect
          const { budget, ...toStore } = campaign;
          localStorage.setItem(key, JSON.stringify(toStore));
        } else {
          localStorage.removeItem(key);
        }
      }
    },
    update: (fn: (state: SelectedCampaignState | null) => SelectedCampaignState | null) => {
      update((state) => {
        const newState = fn(state);
        if (browser) {
          const key = getStorageKey(currentUserId);
          if (newState) {
            const { budget, ...toStore } = newState;
            localStorage.setItem(key, JSON.stringify(toStore));
          } else {
            localStorage.removeItem(key);
          }
        }
        return newState;
      });
    },
    clear: () => {
      set(null);
      if (browser) {
        const key = getStorageKey(currentUserId);
        localStorage.removeItem(key);
      }
    },
    /**
     * Set the current user context and restore their campaign from localStorage.
     * Call this on mount and after account switches.
     */
    setUser: (userId: string | undefined) => {
      // If same user, don't overwrite — the store may have fresher data than localStorage
      if (currentUserId === userId) return;
      currentUserId = userId;
      if (browser && userId) {
        const key = getStorageKey(userId);
        const stored = localStorage.getItem(key);
        // Only restore from localStorage if the store is empty or has a different campaign
        const current = get({ subscribe });
        if (stored) {
          try {
            const parsed = JSON.parse(stored) as SelectedCampaignState;
            // Don't overwrite if store already has this campaign (it may have fresher data like budget)
            if (!current || current.id !== parsed.id) {
              set(parsed);
            }
          } catch (e) {
            console.error('Error restoring selected campaign for user:', e);
            if (!current) set(null);
          }
        } else if (!current) {
          set(null);
        }
        // Migrate old global key to user-scoped key (one-time migration)
        const oldKey = 'neoad_selected_campaign_state';
        const oldStored = localStorage.getItem(oldKey);
        if (oldStored && !stored) {
          // Only migrate if the new key didn't have data yet
          localStorage.setItem(key, oldStored);
          localStorage.removeItem(oldKey);
          try {
            const parsed = JSON.parse(oldStored);
            if (!current || current.id !== parsed.id) {
              set(parsed);
            }
          } catch (e) {
            // ignore
          }
        } else if (oldStored) {
          // Clean up old global key
          localStorage.removeItem(oldKey);
        }
      } else if (!userId) {
        set(null);
      }
    },
    // Legacy restore — now delegates to setUser
    restore: () => {
      if (browser) {
        const key = getStorageKey(currentUserId);
        const stored = localStorage.getItem(key);
        if (stored) {
          try {
            set(JSON.parse(stored));
          } catch (e) {
            console.error('Error restoring selected campaign:', e);
          }
        }
      }
    },
    /**
     * Synchronously read the cached state from localStorage for a given user.
     * Use this to initialize component state without waiting for $effect.
     */
    getInitialState: (userId?: string): SelectedCampaignState | null => {
      if (!browser || !userId) return null;
      const key = getStorageKey(userId);
      const stored = localStorage.getItem(key);
      if (stored) {
        try {
          return JSON.parse(stored);
        } catch {
          return null;
        }
      }
      return null;
    }
  };
}

export const selectedCampaignStore = createSelectedCampaignStore();