import { useQuery, useMutation } from "@tanstack/react-query"
import { queryClient } from "../client"
import {
  fetchAssistantAssignedNumber,
  fetchAssistantAvailableNumbers,
  submitWhatsAppEmbeddedSignup,
  getWhatsAppEmbeddedSignup,
  WhatsAppEmbeddedSignupPayload,
  assignAssistantPhoneNumber,
  getAssistantAssignedNumber,
  getAssistantAssignedSMSNumber,
  getAssistantAvailableNumbers,
  assignAssistantNumber,
  fetchAssistantNumbersPricing,
  getAssistantNumbersPricing,
  fetchVoiceChatSessionId,
  sendCall,
  getAssistantTrainingData,
  fetchAssistantTrainingData,
  updateAssistantTrainingData,
  getAssistantVoices,
  fetchAssistantVoices,
  getVoiceSettings,
  fetchVoiceSettings,
  updateVoiceSettings,
  getWhatsAppConnectionStatus,
  fetchWhatsAppConnectionStatus,
  getInstagramConnectionStatus,
  fetchInstagramConnectionStatus,
  getChatHistory,
  fetchChatHistory,
  ChatMessage,
  fetchAssistantAssignedSMSNumber,
  stopInstagramEvents,
  stopWhatsAppEvents,
} from "../queries/assistant"
import { AssistantAssignedNumberResponse, AssistantAssignedSMSNumberResponse, PhoneNumberOption, AvailablePhoneNumbersResponse, PhoneNumberPricing, AssistantVoiceMapping, AssistantVoiceSettings, AssistantVoiceSettingsResponse, WhatsAppConnectionStatus, InstagramConnectionStatus } from "@/types/assistant"
import { useToaster } from "@/context/ToasterContext"



export function useGetAssistantAssignedNumber() {
  return useQuery<AssistantAssignedNumberResponse>({
    queryKey: getAssistantAssignedNumber,
    queryFn: () => fetchAssistantAssignedNumber()
  })
}

export function useGetAssistantAssignedSMSNumber() {
  return useQuery<AssistantAssignedSMSNumberResponse>({
    queryKey: getAssistantAssignedSMSNumber,
    queryFn: () => fetchAssistantAssignedSMSNumber()
  })
}

export function useGetAssistantAvailableNumbers({ countryCode, type = "local" }: { countryCode?: string, type?: string } = {}) {
  return useQuery<AvailablePhoneNumbersResponse>({
    queryKey: [...getAssistantAvailableNumbers(countryCode), type],
    queryFn: () => fetchAssistantAvailableNumbers(countryCode, type),
    enabled: !!countryCode
  })
}
export function useGetAssistantNumbersPricing({ countryCode }: { countryCode?: string } = {}) {
  return useQuery<PhoneNumberPricing>({
    queryKey: getAssistantNumbersPricing(countryCode),
    queryFn: () => fetchAssistantNumbersPricing(countryCode),
    enabled: !!countryCode
  })
}

export function useAssignAssistantNumber() {
  return useMutation({
    mutationKey: assignAssistantNumber,
    mutationFn: (phoneNumber: string) => assignAssistantPhoneNumber(phoneNumber),
    onSuccess: () => {
      // Invalidate the assigned number query to refetch
      queryClient.invalidateQueries({ queryKey: getAssistantAssignedNumber })
    }
  })
}

export function useGetVoiceChatSessionId() {
  return useMutation({
    mutationFn: (phoneNumber: string) => fetchVoiceChatSessionId(phoneNumber)
  })
}

export function useSendCall() {
  const toast = useToaster()
  return useMutation({
    mutationFn: (payload: { from: string; to: string }) => sendCall(payload),
    onSuccess: (data) => {
      toast.showSuccess("Call initiated successfully! You will receive a call shortly.")
    },
    onError: (error: any) => {
      const errorMessage = error?.response?.data?.message || error?.message || "Failed to initiate call"
      toast.showError(errorMessage)
    }
  })
}


export function useGetAssistantTrainingData() {
  return useQuery<{ trainingData?: string; _id: string }>({
    queryKey: getAssistantTrainingData,
    queryFn: fetchAssistantTrainingData
  })
}

export function useUpdateAssistantTrainingData() {
  const toast = useToaster()
  return useMutation({
    mutationFn: (payload: { trainingData: string }) => updateAssistantTrainingData(payload),
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: getAssistantTrainingData })
    },
    onError: (error: any) => {
      const errorMessage = error?.response?.data?.message || error?.message || "Failed to update training data"
      toast.showError(errorMessage)
    }
  })
}

export function useGetAssistantVoices() {
  return useQuery<AssistantVoiceMapping[]>({
    queryKey: getAssistantVoices,
    queryFn: fetchAssistantVoices
  })
}

export function useGetVoiceSettings() {
  return useQuery<AssistantVoiceSettingsResponse>({
    queryKey: getVoiceSettings,
    queryFn: fetchVoiceSettings
  })
}

export function useUpdateVoiceSettings() {
  const toast = useToaster()
  return useMutation({
    mutationFn: (payload: AssistantVoiceSettings) => updateVoiceSettings(payload),
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: getVoiceSettings })
      toast.showSuccess("Voice settings updated successfully!")
    },
    onError: (error: any) => {
      const errorMessage = error?.response?.data?.message || error?.message || "Failed to update voice settings"
      toast.showError(errorMessage)
    }
  })
}


export function useWhatsAppEmbeddedSignup() {
  const toast = useToaster()
  return useMutation({
    mutationKey: getWhatsAppEmbeddedSignup,
    mutationFn: (payload: WhatsAppEmbeddedSignupPayload) => submitWhatsAppEmbeddedSignup(payload),
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: getWhatsAppConnectionStatus })
      toast.showSuccess("WhatsApp Business account connected successfully!")
    },
    onError: (error: any) => {
      const errorMessage = error?.response?.data?.message || error?.message || "Failed to connect WhatsApp Business account"
      toast.showError(errorMessage)
    }
  })
}

export function useGetWhatsAppConnectionStatus() {
  return useQuery<WhatsAppConnectionStatus>({
    queryKey: getWhatsAppConnectionStatus,
    queryFn: fetchWhatsAppConnectionStatus
  })
}

export function useGetInstagramConnectionStatus() {
  return useQuery<InstagramConnectionStatus>({
    queryKey: getInstagramConnectionStatus,
    queryFn: fetchInstagramConnectionStatus
  })
}

export function useGetChatHistory(chatId: string, enabled: boolean = false, platformUsed: string = "") {
  return useQuery<ChatMessage[]>({
    queryKey: getChatHistory(chatId, platformUsed),
    queryFn: () => fetchChatHistory(chatId, platformUsed),
    enabled: !!chatId && enabled,
    refetchOnWindowFocus: false,
  })
}

export function useStopInstagramEvents() {
  const toast = useToaster()
  return useMutation({
    mutationFn: stopInstagramEvents,
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: getInstagramConnectionStatus })
      toast.showSuccess("Instagram integration deactivated successfully!")
    },
    onError: (error: any) => {
      const errorMessage = error?.response?.data?.message || error?.message || "Failed to deactivate Instagram integration"
      toast.showError(errorMessage)
    }
  })
}

export function useStopWhatsAppEvents() {
  const toast = useToaster()
  return useMutation({
    mutationFn: stopWhatsAppEvents,
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: getWhatsAppConnectionStatus })
      toast.showSuccess("WhatsApp integration deactivated successfully!")
    },
    onError: (error: any) => {
      const errorMessage = error?.response?.data?.message || error?.message || "Failed to deactivate WhatsApp integration"
      toast.showError(errorMessage)
    }
  })
}