import { useState, useCallback, useEffect } from 'react'
import { EmailVerificationSettings, defaultSettings, PendingUser } from '../config'

export function useEmailVerificationSettings() {
  const [settings, setSettings] = useState<EmailVerificationSettings>(defaultSettings)
  const [originalSettings, setOriginalSettings] = useState<EmailVerificationSettings>(defaultSettings)
  const [pendingUsers, setPendingUsers] = useState<PendingUser[]>([])
  const [pendingTotal, setPendingTotal] = useState(0)
  const [pendingStats, setPendingStats] = useState({ pending: 0, expired: 0, resends: 0 })
  const [isSaving, setIsSaving] = useState(false)
  const [isLoading, setIsLoading] = useState(true)
  const [isLoadingUsers, setIsLoadingUsers] = useState(false)
  const [hasChanges, setHasChanges] = useState(false)

  // Load settings from API
  useEffect(() => {
    const loadSettings = async () => {
      try {
        const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
        const response = await fetch(`${apiUrl}/email-verification/settings`, {
          headers: {
            'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
          },
        })
        
        if (response.ok) {
          const result = await response.json()
          if (result.success && result.data) {
            const loadedSettings = { ...defaultSettings, ...result.data }
            setSettings(loadedSettings)
            setOriginalSettings(loadedSettings)
          }
        }
      } catch (error) {
        console.error('Failed to load email verification 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 EmailVerificationSettings>(
    key: K,
    value: EmailVerificationSettings[K]
  ) => {
    setSettings(prev => ({ ...prev, [key]: value }))
  }, [])

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

  const saveSettings = useCallback(async () => {
    setIsSaving(true)
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      
      const response = await fetch(`${apiUrl}/email-verification/settings`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify(settings),
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success) {
          setOriginalSettings(settings)
          setHasChanges(false)
          return { success: true, message: result.message }
        }
      }
      
      return { success: false, error: 'Failed to save settings' }
    } catch (error) {
      console.error('Failed to save settings:', error)
      return { success: false, error }
    } finally {
      setIsSaving(false)
    }
  }, [settings])

  // Load pending users
  const loadPendingUsers = useCallback(async (page = 1, perPage = 10, search = '') => {
    setIsLoadingUsers(true)
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      const query = new URLSearchParams({ page: String(page), per_page: String(perPage) })
      if (search.trim()) query.set('search', search.trim())
      const response = await fetch(`${apiUrl}/email-verification/pending-users?${query.toString()}`, {
        headers: {
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success && result.data) {
          setPendingUsers(result.data)
          setPendingTotal(Number(result.total) || 0)
          if (result.stats) setPendingStats(result.stats)
        }
      }
    } catch (error) {
      console.error('Failed to load pending users:', error)
    } finally {
      setIsLoadingUsers(false)
    }
  }, [])

  // Verify user manually
  const verifyUser = useCallback(async (userId: number) => {
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      const response = await fetch(`${apiUrl}/email-verification/verify-user`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify({ userId }),
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success) {
          setPendingUsers(prev => prev.filter(u => u.id !== userId))
          return { success: true }
        }
      }
      return { success: false }
    } catch (error) {
      console.error('Failed to verify user:', error)
      return { success: false, error }
    }
  }, [])

  // Delete unverified user
  const deleteUser = useCallback(async (userId: number) => {
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      const response = await fetch(`${apiUrl}/email-verification/delete-user`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify({ userId }),
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success) {
          setPendingUsers(prev => prev.filter(u => u.id !== userId))
          return { success: true }
        }
      }
      return { success: false }
    } catch (error) {
      console.error('Failed to delete user:', error)
      return { success: false, error }
    }
  }, [])

  // Resend verification email
  const resendVerification = useCallback(async (userId: number) => {
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      const response = await fetch(`${apiUrl}/email-verification/resend`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify({ userId }),
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success) {
          // Update resend count in local state
          setPendingUsers(prev => prev.map(u => 
            u.id === userId ? { ...u, resendCount: u.resendCount + 1, verificationSentAt: new Date().toISOString() } : u
          ))
          return { success: true }
        }
      }
      return { success: false }
    } catch (error) {
      console.error('Failed to resend verification:', error)
      return { success: false, error }
    }
  }, [])

  // Bulk verify users
  const bulkVerify = useCallback(async (userIds: number[]) => {
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      const response = await fetch(`${apiUrl}/email-verification/bulk-verify`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify({ userIds }),
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success) {
          setPendingUsers(prev => prev.filter(u => !userIds.includes(u.id)))
          return { success: true }
        }
      }
      return { success: false }
    } catch (error) {
      console.error('Failed to bulk verify:', error)
      return { success: false, error }
    }
  }, [])

  // Approve user (Admin Approval mode)
  const approveUser = useCallback(async (userId: number) => {
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      const response = await fetch(`${apiUrl}/email-verification/approve-user`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify({ userId }),
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success) {
          setPendingUsers(prev => prev.filter(u => u.id !== userId))
          return { success: true }
        }
      }
      return { success: false }
    } catch (error) {
      console.error('Failed to approve user:', error)
      return { success: false, error }
    }
  }, [])

  // Bulk approve users (Admin Approval mode)
  const bulkApprove = useCallback(async (userIds: number[]) => {
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      const response = await fetch(`${apiUrl}/email-verification/bulk-approve`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify({ userIds }),
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success) {
          setPendingUsers(prev => prev.filter(u => !userIds.includes(u.id)))
          return { success: true }
        }
      }
      return { success: false }
    } catch (error) {
      console.error('Failed to bulk approve:', error)
      return { success: false, error }
    }
  }, [])

  // Reject user (Admin Approval mode) — sends rejection email and deletes user
  const rejectUser = useCallback(async (userId: number) => {
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      const response = await fetch(`${apiUrl}/email-verification/reject-user`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify({ userId }),
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success) {
          setPendingUsers(prev => prev.filter(u => u.id !== userId))
          return { success: true }
        }
      }
      return { success: false }
    } catch (error) {
      console.error('Failed to reject user:', error)
      return { success: false, error }
    }
  }, [])

  // Bulk reject users (Admin Approval mode)
  const bulkReject = useCallback(async (userIds: number[]) => {
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      const response = await fetch(`${apiUrl}/email-verification/bulk-reject`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify({ userIds }),
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success) {
          setPendingUsers(prev => prev.filter(u => !userIds.includes(u.id)))
          return { success: true }
        }
      }
      return { success: false }
    } catch (error) {
      console.error('Failed to bulk reject:', error)
      return { success: false, error }
    }
  }, [])

  // Bulk delete unverified users
  const bulkDelete = useCallback(async (userIds: number[]) => {
    try {
      const apiUrl = window.swiftCommerceData?.apiUrl || '/wp-json/swift-commerce/v1'
      const response = await fetch(`${apiUrl}/email-verification/bulk-delete`, {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
          'X-WP-Nonce': window.swiftCommerceData?.restNonce || '',
        },
        body: JSON.stringify({ userIds }),
      })
      
      if (response.ok) {
        const result = await response.json()
        if (result.success) {
          setPendingUsers(prev => prev.filter(u => !userIds.includes(u.id)))
          return { success: true }
        }
      }
      return { success: false }
    } catch (error) {
      console.error('Failed to bulk delete:', error)
      return { success: false, error }
    }
  }, [])

  return {
    settings,
    originalSettings,
    pendingUsers,
    pendingTotal,
    pendingStats,
    saving: isSaving,
    loading: isLoading,
    loadingUsers: isLoadingUsers,
    hasChanges,
    updateSettings,
    toggleRole,
    saveSettings,
    loadPendingUsers,
    verifyUser,
    deleteUser,
    resendVerification,
    bulkVerify,
    bulkDelete,
    approveUser,
    bulkApprove,
    rejectUser,
    bulkReject,
  }
}

// Export alias for consistency
export const useEmailVerification = useEmailVerificationSettings