'use client'

import { useCallback } from 'react'
import { 
  trackAuth, 
  trackBook, 
  trackAI, 
  trackSubscription, 
  trackTemplate, 
  trackUsage, 
  trackContent,
  trackError 
} from '@/lib/analytics'

// Hook for authentication tracking
export const useAuthTracking = () => {
  const trackLogin = useCallback((method: string = 'google') => {
    trackAuth.login(method)
  }, [])

  const trackSignUp = useCallback((method: string = 'google') => {
    trackAuth.signUp(method)
  }, [])

  const trackLogout = useCallback(() => {
    trackAuth.logout()
  }, [])

  return { trackLogin, trackSignUp, trackLogout }
}

// Hook for book-related tracking
export const useBookTracking = () => {
  const trackBookCreate = useCallback((templateId?: string) => {
    trackBook.create(templateId)
  }, [])

  const trackBookOpen = useCallback((bookId: string) => {
    trackBook.open(bookId)
  }, [])

  const trackBookEdit = useCallback((bookId: string, action: 'file_create' | 'file_edit' | 'file_delete') => {
    trackBook.edit(bookId, action)
  }, [])

  const trackBookDelete = useCallback((bookId: string) => {
    trackBook.delete(bookId)
  }, [])

  return { trackBookCreate, trackBookOpen, trackBookEdit, trackBookDelete }
}

// Hook for AI operations tracking
export const useAITracking = () => {
  const trackChatMessage = useCallback((bookId: string, messageLength: number, model: string) => {
    trackAI.chatMessage(bookId, messageLength, model)
  }, [])

  const trackAIOperation = useCallback((operationType: string, bookId: string, success: boolean) => {
    trackAI.operation(operationType, bookId, success)
  }, [])

  const trackAIRevert = useCallback((operationId: string, bookId: string) => {
    trackAI.revert(operationId, bookId)
  }, [])

  return { trackChatMessage, trackAIOperation, trackAIRevert }
}

// Hook for subscription tracking
export const useSubscriptionTracking = () => {
  const trackCheckoutStart = useCallback((planType: string, planPrice: number) => {
    trackSubscription.checkoutStart(planType, planPrice)
  }, [])

  const trackPurchase = useCallback((planType: string, planPrice: number, transactionId: string) => {
    trackSubscription.purchase(planType, planPrice, transactionId)
  }, [])

  const trackCancel = useCallback((planType: string) => {
    trackSubscription.cancel(planType)
  }, [])

  const trackUpgrade = useCallback((fromPlan: string, toPlan: string) => {
    trackSubscription.upgrade(fromPlan, toPlan)
  }, [])

  return { trackCheckoutStart, trackPurchase, trackCancel, trackUpgrade }
}

// Hook for template tracking
export const useTemplateTracking = () => {
  const trackTemplateView = useCallback((templateId: string) => {
    trackTemplate.view(templateId)
  }, [])

  const trackTemplateUse = useCallback((templateId: string) => {
    trackTemplate.use(templateId)
  }, [])

  return { trackTemplateView, trackTemplateUse }
}

// Hook for general usage tracking
export const useUsageTracking = () => {
  const trackFeatureUse = useCallback((feature: string, context?: string) => {
    trackUsage.featureUse(feature, context)
  }, [])

  const trackSearch = useCallback((query: string, resultsCount: number) => {
    trackUsage.searchQuery(query, resultsCount)
  }, [])

  return { trackFeatureUse, trackSearch }
}

// Hook for content engagement tracking
export const useContentTracking = () => {
  const trackBlogView = useCallback((slug: string, title: string) => {
    trackContent.blogView(slug, title)
  }, [])

  const trackBlogEngagement = useCallback((slug: string, action: 'scroll_50' | 'scroll_90' | 'time_on_page') => {
    trackContent.blogEngagement(slug, action)
  }, [])

  return { trackBlogView, trackBlogEngagement }
}

// Hook for error tracking
export const useErrorTracking = () => {
  const trackJSError = useCallback((error: Error, context?: string) => {
    trackError.jsError(error, context)
  }, [])

  const trackAPIError = useCallback((endpoint: string, statusCode: number, errorMessage: string) => {
    trackError.apiError(endpoint, statusCode, errorMessage)
  }, [])

  return { trackJSError, trackAPIError }
}