/**
 * Onboarding state storage utilities
 * Simple localStorage wrapper following announcement-storage.ts pattern
 * Provides atomic writes to prevent race conditions
 */

export interface OnboardingState {
  completedSteps: string[];
  skippedSteps: string[];
  dismissed: boolean;
  lastUpdated: string;
}

const DEFAULT_STATE: OnboardingState = {
  completedSteps: [],
  skippedSteps: [],
  dismissed: false,
  lastUpdated: new Date().toISOString(),
};

/**
 * Save onboarding state to localStorage (atomic write)
 */
export function saveOnboardingState(key: string, state: OnboardingState): void {
  if (typeof window === 'undefined') return;

  try {
    localStorage.setItem(key, JSON.stringify(state));
    console.log('💾 Saved onboarding state:', state);

    // Dispatch custom event for cross-tab sync
    if (typeof window !== 'undefined') {
      window.dispatchEvent(
        new CustomEvent('localStorageUpdate', {
          detail: { key, newValue: JSON.stringify(state) },
        }),
      );
    }
  } catch (err) {
    console.warn('[onboarding-storage] Failed saving to localStorage:', err);
  }
}

/**
 * Load onboarding state from localStorage
 */
export function loadOnboardingState(key: string): OnboardingState {
  if (typeof window === 'undefined') return DEFAULT_STATE;

  try {
    const raw = localStorage.getItem(key);
    if (!raw) return DEFAULT_STATE;

    const parsed = JSON.parse(raw) as OnboardingState;
    return parsed;
  } catch (err) {
    console.warn('[onboarding-storage] Failed parsing localStorage data:', err);
    return DEFAULT_STATE;
  }
}

/**
 * Mark multiple steps as complete in a single atomic update
 */
export function markMultipleComplete(key: string, stepIds: string[]): OnboardingState {
  const state = loadOnboardingState(key);
  const newState: OnboardingState = {
    ...state,
    completedSteps: [...new Set([...state.completedSteps, ...stepIds])],
    skippedSteps: state.skippedSteps.filter(id => !stepIds.includes(id)),
    lastUpdated: new Date().toISOString(),
  };
  saveOnboardingState(key, newState);
  return newState;
}

/**
 * Mark a single step as complete
 */
export function markStepComplete(key: string, stepId: string): OnboardingState {
  return markMultipleComplete(key, [stepId]);
}

/**
 * Mark a step as skipped
 */
export function markStepSkipped(key: string, stepId: string): OnboardingState {
  const state = loadOnboardingState(key);
  const newState: OnboardingState = {
    ...state,
    skippedSteps: [...new Set([...state.skippedSteps, stepId])],
    completedSteps: state.completedSteps.filter(id => id !== stepId),
    lastUpdated: new Date().toISOString(),
  };
  saveOnboardingState(key, newState);
  return newState;
}

/**
 * Dismiss the onboarding walkthrough
 */
export function dismissOnboarding(key: string): OnboardingState {
  const state = loadOnboardingState(key);
  const newState: OnboardingState = {
    ...state,
    dismissed: true,
    lastUpdated: new Date().toISOString(),
  };
  saveOnboardingState(key, newState);
  return newState;
}

/**
 * Check if a step is complete
 */
export function isStepComplete(key: string, stepId: string): boolean {
  const state = loadOnboardingState(key);
  return state.completedSteps.includes(stepId);
}

/**
 * Check if a step is skipped
 */
export function isStepSkipped(key: string, stepId: string): boolean {
  const state = loadOnboardingState(key);
  return state.skippedSteps.includes(stepId);
}

/**
 * Check if onboarding is dismissed
 */
export function isOnboardingDismissed(key: string): boolean {
  const state = loadOnboardingState(key);
  return state.dismissed;
}