apps/ui/src/store/setup-store.ts

import { create } from 'zustand';
import type { GeminiAuthStatus } from '@automaker/types';
// Note: persist middleware removed - settings now sync via API (use-settings-sync.ts)

// CLI Installation Status
export interface CliStatus {
  installed: boolean;
  path: string | null;
  version: string | null;
  method: string;
  hasApiKey?: boolean;
  error?: string;
}

// GitHub CLI Status
export interface GhCliStatus {
  installed: boolean;
  authenticated: boolean;
  version: string | null;
  path: string | null;
  user: string | null;
  error?: string;
}

// Cursor CLI Status
export interface CursorCliStatus {
  installed: boolean;
  version?: string | null;
  path?: string | null;
  auth?: {
    authenticated: boolean;
    method: string;
  };
  installCommand?: string;
  loginCommand?: string;
  error?: string;
}

// Codex CLI Status
export interface CodexCliStatus {
  installed: boolean;
  version?: string | null;
  path?: string | null;
  auth?: {
    authenticated: boolean;
    method: string;
  };
  installCommand?: string;
  loginCommand?: string;
  error?: string;
}

// OpenCode CLI Status
export interface OpencodeCliStatus {
  installed: boolean;
  version?: string | null;
  path?: string | null;
  auth?: {
    authenticated: boolean;
    method: string;
  };
  installCommand?: string;
  loginCommand?: string;
  error?: string;
}

// Gemini CLI Status
export interface GeminiCliStatus {
  installed: boolean;
  version?: string | null;
  path?: string | null;
  auth?: {
    authenticated: boolean;
    method: string;
    hasApiKey?: boolean;
    hasEnvApiKey?: boolean;
  };
  installCommand?: string;
  loginCommand?: string;
  error?: string;
}

// Copilot SDK Status
export interface CopilotCliStatus {
  installed: boolean;
  version?: string | null;
  path?: string | null;
  auth?: {
    authenticated: boolean;
    method: string;
    login?: string;
    host?: string;
  };
  installCommand?: string;
  loginCommand?: string;
  error?: string;
}

// Codex Auth Method
export type CodexAuthMethod =
  | 'api_key_env' // OPENAI_API_KEY environment variable
  | 'api_key' // Manually stored API key
  | 'cli_authenticated' // Codex CLI is installed and authenticated
  | 'none';

// Codex Auth Status
export interface CodexAuthStatus {
  authenticated: boolean;
  method: CodexAuthMethod;
  hasAuthFile?: boolean;
  hasApiKey?: boolean;
  hasEnvApiKey?: boolean;
  error?: string;
}

// z.ai Auth Method
export type ZaiAuthMethod =
  | 'api_key_env' // Z_AI_API_KEY environment variable
  | 'api_key' // Manually stored API key
  | 'none';

// z.ai Auth Status
export interface ZaiAuthStatus {
  authenticated: boolean;
  method: ZaiAuthMethod;
  hasApiKey?: boolean;
  hasEnvApiKey?: boolean;
  error?: string;
}

// GeminiAuthStatus is imported from @automaker/types (method: 'google_login' | 'api_key' | 'vertex_ai' | 'none')
export type { GeminiAuthStatus };

// Claude Auth Method - all possible authentication sources
export type ClaudeAuthMethod =
  | 'oauth_token_env'
  | 'oauth_token' // Stored OAuth token from claude login
  | 'api_key_env' // ANTHROPIC_API_KEY environment variable
  | 'api_key' // Manually stored API key
  | 'credentials_file' // Generic credentials file detection
  | 'cli_authenticated' // Claude CLI is installed and has active sessions/activity
  | 'none';

// Claude Auth Status
export interface ClaudeAuthStatus {
  authenticated: boolean;
  method: ClaudeAuthMethod;
  hasCredentialsFile?: boolean;
  oauthTokenValid?: boolean;
  apiKeyValid?: boolean;
  hasEnvOAuthToken?: boolean;
  hasEnvApiKey?: boolean;
  error?: string;
}

// Installation Progress
export interface InstallProgress {
  isInstalling: boolean;
  currentStep: string;
  progress: number; // 0-100
  output: string[];
  error?: string;
}

export type SetupStep =
  | 'welcome'
  | 'theme'
  | 'providers'
  | 'claude_detect'
  | 'claude_auth'
  | 'cursor'
  | 'codex'
  | 'opencode'
  | 'gemini'
  | 'copilot'
  | 'github'
  | 'complete';

export interface SetupState {
  // Setup wizard state
  isFirstRun: boolean;
  setupComplete: boolean;
  currentStep: SetupStep;

  // Claude CLI state
  claudeCliStatus: CliStatus | null;
  claudeAuthStatus: ClaudeAuthStatus | null;
  claudeInstallProgress: InstallProgress;
  claudeIsVerifying: boolean;

  // GitHub CLI state
  ghCliStatus: GhCliStatus | null;

  // Cursor CLI state
  cursorCliStatus: CursorCliStatus | null;

  // Codex CLI state
  codexCliStatus: CliStatus | null;
  codexAuthStatus: CodexAuthStatus | null;
  codexInstallProgress: InstallProgress;

  // OpenCode CLI state
  opencodeCliStatus: OpencodeCliStatus | null;

  // Gemini CLI state
  geminiCliStatus: GeminiCliStatus | null;
  geminiAuthStatus: GeminiAuthStatus | null;

  // Copilot SDK state
  copilotCliStatus: CopilotCliStatus | null;

  // z.ai API state
  zaiAuthStatus: ZaiAuthStatus | null;

  // Setup preferences
  skipClaudeSetup: boolean;
}

export interface SetupActions {
  // Setup flow
  setCurrentStep: (step: SetupStep) => void;
  setSetupComplete: (complete: boolean) => void;
  completeSetup: () => void;
  resetSetup: () => void;
  setIsFirstRun: (isFirstRun: boolean) => void;

  // Claude CLI
  setClaudeCliStatus: (status: CliStatus | null) => void;
  setClaudeAuthStatus: (status: ClaudeAuthStatus | null) => void;
  setClaudeInstallProgress: (progress: Partial<InstallProgress>) => void;
  resetClaudeInstallProgress: () => void;
  setClaudeIsVerifying: (isVerifying: boolean) => void;

  // GitHub CLI
  setGhCliStatus: (status: GhCliStatus | null) => void;

  // Cursor CLI
  setCursorCliStatus: (status: CursorCliStatus | null) => void;

  // Codex CLI
  setCodexCliStatus: (status: CliStatus | null) => void;
  setCodexAuthStatus: (status: CodexAuthStatus | null) => void;
  setCodexInstallProgress: (progress: Partial<InstallProgress>) => void;
  resetCodexInstallProgress: () => void;

  // OpenCode CLI
  setOpencodeCliStatus: (status: OpencodeCliStatus | null) => void;

  // Gemini CLI
  setGeminiCliStatus: (status: GeminiCliStatus | null) => void;
  setGeminiAuthStatus: (status: GeminiAuthStatus | null) => void;

  // Copilot SDK
  setCopilotCliStatus: (status: CopilotCliStatus | null) => void;

  // z.ai API
  setZaiAuthStatus: (status: ZaiAuthStatus | null) => void;

  // Preferences
  setSkipClaudeSetup: (skip: boolean) => void;
}

const initialInstallProgress: InstallProgress = {
  isInstalling: false,
  currentStep: '',
  progress: 0,
  output: [],
};

// Check if setup should be skipped (for E2E testing)
const shouldSkipSetup = import.meta.env.VITE_SKIP_SETUP === 'true';

/**
 * Pre-flight check: read setupComplete from localStorage settings cache so that
 * the routing effect in __root.tsx doesn't flash /setup for returning users.
 *
 * The setup store is intentionally NOT persisted (settings sync via API), but on
 * first render the routing check fires before the initAuth useEffect can call
 * hydrateStoreFromSettings(). If setupComplete starts as false, returning users
 * who have completed setup see a /setup redirect flash.
 *
 * Reading from localStorage here is safe: it's the same key used by
 * parseLocalStorageSettings() and written by the settings sync hook.
 * On first-ever visit (no cache), this returns false as expected.
 */
function getInitialSetupComplete(): boolean {
  if (shouldSkipSetup) return true;
  try {
    const raw = localStorage.getItem('automaker-settings-cache');
    if (raw) {
      const parsed = JSON.parse(raw) as { setupComplete?: boolean };
      if (parsed?.setupComplete === true) return true;
    }
  } catch {
    // localStorage unavailable or JSON invalid — fall through
  }
  return false;
}

const initialSetupComplete = getInitialSetupComplete();

const initialState: SetupState = {
  isFirstRun: !shouldSkipSetup && !initialSetupComplete,
  setupComplete: initialSetupComplete,
  currentStep: initialSetupComplete ? 'complete' : 'welcome',

  claudeCliStatus: null,
  claudeAuthStatus: null,
  claudeInstallProgress: { ...initialInstallProgress },
  claudeIsVerifying: false,

  ghCliStatus: null,
  cursorCliStatus: null,

  codexCliStatus: null,
  codexAuthStatus: null,
  codexInstallProgress: { ...initialInstallProgress },

  opencodeCliStatus: null,

  geminiCliStatus: null,
  geminiAuthStatus: null,

  copilotCliStatus: null,

  zaiAuthStatus: null,

  skipClaudeSetup: shouldSkipSetup,
};

export const useSetupStore = create<SetupState & SetupActions>()((set, get) => ({
  ...initialState,

  // Setup flow
  setCurrentStep: (step) => set({ currentStep: step }),

  setSetupComplete: (complete) =>
    set({
      setupComplete: complete,
      currentStep: complete ? 'complete' : 'welcome',
    }),

  completeSetup: () => set({ setupComplete: true, currentStep: 'complete' }),

  resetSetup: () =>
    set({
      ...initialState,
      // Explicitly override runtime-critical fields that may be stale in the
      // module-level initialState (captured at import time from localStorage).
      setupComplete: false,
      currentStep: 'welcome',
      isFirstRun: false, // Don't reset first run flag — user has visited before
    }),

  setIsFirstRun: (isFirstRun) => set({ isFirstRun }),

  // Claude CLI
  setClaudeCliStatus: (status) => set({ claudeCliStatus: status }),

  setClaudeAuthStatus: (status) => set({ claudeAuthStatus: status }),

  setClaudeInstallProgress: (progress) =>
    set({
      claudeInstallProgress: {
        ...get().claudeInstallProgress,
        ...progress,
      },
    }),

  resetClaudeInstallProgress: () =>
    set({
      claudeInstallProgress: { ...initialInstallProgress },
    }),

  setClaudeIsVerifying: (isVerifying) => set({ claudeIsVerifying: isVerifying }),

  // GitHub CLI
  setGhCliStatus: (status) => set({ ghCliStatus: status }),

  // Cursor CLI
  setCursorCliStatus: (status) => set({ cursorCliStatus: status }),

  // Codex CLI
  setCodexCliStatus: (status) => set({ codexCliStatus: status }),

  setCodexAuthStatus: (status) => set({ codexAuthStatus: status }),

  setCodexInstallProgress: (progress) =>
    set({
      codexInstallProgress: {
        ...get().codexInstallProgress,
        ...progress,
      },
    }),

  resetCodexInstallProgress: () =>
    set({
      codexInstallProgress: { ...initialInstallProgress },
    }),

  // OpenCode CLI
  setOpencodeCliStatus: (status) => set({ opencodeCliStatus: status }),

  // Gemini CLI
  setGeminiCliStatus: (status) => set({ geminiCliStatus: status }),
  setGeminiAuthStatus: (status) => set({ geminiAuthStatus: status }),

  // Copilot SDK
  setCopilotCliStatus: (status) => set({ copilotCliStatus: status }),

  // z.ai API
  setZaiAuthStatus: (status) => set({ zaiAuthStatus: status }),

  // Preferences
  setSkipClaudeSetup: (skip) => set({ skipClaudeSetup: skip }),
}));