import { useState, useCallback, useEffect } from 'react'
import { 
  RecaptchaState, 
  defaultRecaptchaState,
  CaptchaProvider,
  RecaptchaVersion,
  RecaptchaV2Mode,
  RecaptchaV3Display,
  RecaptchaLocation,
} from '../config'

export function useRecaptchaSettings() {
  const [settings, setSettings] = useState<RecaptchaState>(defaultRecaptchaState)
  const [originalSettings, setOriginalSettings] = useState<RecaptchaState>(defaultRecaptchaState)
  const [isSaving, setIsSaving] = useState(false)
  const [isLoading, setIsLoading] = useState(true)
  const [hasChanges, setHasChanges] = useState(false)
  const [touchedSecrets, setTouchedSecrets] = useState<Record<string, boolean>>({})

  // Load settings from API
  useEffect(() => {
    const loadSettings = async () => {
      try {
        const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
        const response = await fetch(`${apiUrl}/recaptcha/settings`, {
          headers: {
            'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
          },
        })
        
        if (response.ok) {
          const result = await response.json()
          if (result.success && result.data) {
            const apiData = result.data
            const mappedSettings: RecaptchaState = {
              enabled: apiData.enabled || false,
              provider: apiData.provider || (apiData.enabled || apiData.v2SiteKey || apiData.v3SiteKey || apiData.siteKey ? 'google-recaptcha' : ''),
              version: apiData.version || 'v2',
              // V2 specific - try new keys first, fall back to legacy
              v2SiteKey: apiData.v2SiteKey || (apiData.version === 'v2' ? apiData.siteKey : '') || '',
              v2SecretKey: apiData.v2SecretKey || (apiData.version === 'v2' ? apiData.secretKey : '') || '',
              v2SecretKeyConfigured: Boolean(apiData.v2SecretKeyConfigured),
              v2Mode: apiData.v2Mode || 'checkbox',
              // V3 specific - try new keys first, fall back to legacy
              v3SiteKey: apiData.v3SiteKey || (apiData.version === 'v3' ? apiData.siteKey : '') || '',
              v3SecretKey: apiData.v3SecretKey || (apiData.version === 'v3' ? apiData.secretKey : '') || '',
              v3SecretKeyConfigured: Boolean(apiData.v3SecretKeyConfigured),
              v3Threshold: apiData.v3Threshold ?? 0.5,
              v3Display: apiData.v3Display || 'badge',
              // Legacy keys (synced based on version)
              siteKey: apiData.siteKey || '',
              secretKey: apiData.secretKey || '',
              // Locations
              locations: apiData.locations || defaultRecaptchaState.locations,
              // Pro settings
              theme: apiData.theme || 'light',
              size: apiData.size || 'normal',
              ipWhitelist: apiData.ipWhitelist || '',
              bypassRoles: apiData.bypassRoles || [],
              // Pro provider keys
              turnstileSiteKey: apiData.turnstileSiteKey || '',
              turnstileSecretKey: apiData.turnstileSecretKey || '',
              turnstileSecretKeyConfigured: Boolean(apiData.turnstileSecretKeyConfigured),
              turnstileAppearance: apiData.turnstileAppearance || 'always',
              hcaptchaSiteKey: apiData.hcaptchaSiteKey || '',
              hcaptchaSecretKey: apiData.hcaptchaSecretKey || '',
              hcaptchaSecretKeyConfigured: Boolean(apiData.hcaptchaSecretKeyConfigured),
              hcaptchaMode: apiData.hcaptchaMode || 'visible',
              analyticsEnabled: Boolean(apiData.analyticsEnabled),
              analyticsRetentionDays: apiData.analyticsRetentionDays || 30,
            }
            setSettings(mappedSettings)
            setOriginalSettings(mappedSettings)
          }
        }
      } catch (error) {
        console.error('Failed to load reCAPTCHA settings:', error)
      } finally {
        setIsLoading(false)
      }
    }

    loadSettings()
  }, [])

  // Check for changes
  useEffect(() => {
    setHasChanges(JSON.stringify(settings) !== JSON.stringify(originalSettings))
  }, [settings, originalSettings])

  const updateSettings = useCallback(<K extends keyof RecaptchaState>(
    key: K,
    value: RecaptchaState[K]
  ) => {
    if (['v2SecretKey', 'v3SecretKey', 'turnstileSecretKey', 'hcaptchaSecretKey'].includes(String(key))) {
      setTouchedSecrets(prev => ({ ...prev, [String(key)]: true }))
    }
    setSettings(prev => ({ ...prev, [key]: value }))
  }, [])

  const toggleLocation = useCallback((locationId: RecaptchaLocation) => {
    setSettings(prev => ({
      ...prev,
      locations: {
        ...prev.locations,
        [locationId]: !prev.locations[locationId],
      },
    }))
  }, [])

  const toggleBypassRole = useCallback((role: string) => {
    setSettings(prev => ({
      ...prev,
      bypassRoles: prev.bypassRoles.includes(role)
        ? prev.bypassRoles.filter(r => r !== role)
        : [...prev.bypassRoles, role],
    }))
  }, [])

  const setProvider = useCallback((provider: CaptchaProvider) => {
    updateSettings('provider', provider)
  }, [updateSettings])

  const setVersion = useCallback((version: RecaptchaVersion) => {
    updateSettings('version', version)
  }, [updateSettings])

  const setV2Mode = useCallback((mode: RecaptchaV2Mode) => {
    updateSettings('v2Mode', mode)
  }, [updateSettings])

  const setV3Display = useCallback((display: RecaptchaV3Display) => {
    updateSettings('v3Display', display)
  }, [updateSettings])

  const resetToDefaults = useCallback(() => {
    setSettings(defaultRecaptchaState)
    setTouchedSecrets({
      v2SecretKey: true,
      v3SecretKey: true,
      turnstileSecretKey: true,
      hcaptchaSecretKey: true,
    })
  }, [])

  const saveSettings = useCallback(async () => {
    setIsSaving(true)
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      
      // Sync legacy keys based on selected version for backend compatibility
      const settingsToSave = {
        ...settings,
        // Set legacy keys based on selected version
        siteKey: settings.version === 'v2' ? settings.v2SiteKey : settings.v3SiteKey,
        secretKey: settings.version === 'v2' ? settings.v2SecretKey : settings.v3SecretKey,
        clearV2SecretKey: Boolean(touchedSecrets.v2SecretKey && !settings.v2SecretKey),
        clearV3SecretKey: Boolean(touchedSecrets.v3SecretKey && !settings.v3SecretKey),
        clearSecretKey: Boolean(settings.version === 'v2'
          ? touchedSecrets.v2SecretKey && !settings.v2SecretKey
          : touchedSecrets.v3SecretKey && !settings.v3SecretKey),
        clearTurnstileSecretKey: Boolean(touchedSecrets.turnstileSecretKey && !settings.turnstileSecretKey),
        clearHcaptchaSecretKey: Boolean(touchedSecrets.hcaptchaSecretKey && !settings.hcaptchaSecretKey),
      }
      
      const response = await fetch(`${apiUrl}/recaptcha/settings`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify(settingsToSave),
      })
      
      const result = await response.json().catch(() => null)
      if (response.ok) {
        if (result.success) {
          const savedSettings: RecaptchaState = {
            ...settings,
            v2SecretKey: '',
            v2SecretKeyConfigured: Boolean(settings.v2SecretKey || (settings.v2SecretKeyConfigured && !settingsToSave.clearV2SecretKey)),
            v3SecretKey: '',
            v3SecretKeyConfigured: Boolean(settings.v3SecretKey || (settings.v3SecretKeyConfigured && !settingsToSave.clearV3SecretKey)),
            turnstileSecretKey: '',
            turnstileSecretKeyConfigured: Boolean(settings.turnstileSecretKey || (settings.turnstileSecretKeyConfigured && !settingsToSave.clearTurnstileSecretKey)),
            hcaptchaSecretKey: '',
            hcaptchaSecretKeyConfigured: Boolean(settings.hcaptchaSecretKey || (settings.hcaptchaSecretKeyConfigured && !settingsToSave.clearHcaptchaSecretKey)),
          }
          setOriginalSettings(savedSettings)
          setSettings(savedSettings)
          setTouchedSecrets({})
          setHasChanges(false)
          return { success: true, message: result.message }
        }
        return { success: false, error: result.message || 'Failed to save settings' }
      }
      
      return { success: false, error: result?.message || 'Failed to save settings' }
    } catch (error) {
      console.error('Failed to save settings:', error)
      return { success: false, error }
    } finally {
      setIsSaving(false)
    }
  }, [settings, touchedSecrets])

  return {
    settings,
    isSaving,
    isLoading,
    hasChanges,
    updateSettings,
    toggleLocation,
    toggleBypassRole,
    setProvider,
    setVersion,
    setV2Mode,
    setV3Display,
    saveSettings,
    resetToDefaults,
  }
}