'use client'

import type { FormSettingsData } from '@admin/actions/forms'
import type {
  WebhookDeliveriesPage,
  WebhookDeliveriesQuery,
  WebhookSubscriptionEntry,
  WebhooksPage,
  WebhooksQuery
} from '@admin/actions/webhooks'
import type { UseQueryResult } from '@tanstack/react-query'
import { getAllFormSettings } from '@admin/actions/forms'
import {
  getWebhookDeliveries,
  getWebhookSubscriptions,
  getWebhooks,
  sendTestWebhook,
  updateWebhook
} from '@admin/actions/webhooks'
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import { toast } from 'sonner'

export function useWebhooks(
  search?: string,
  enabled?: string,
  lastDelivery?: string,
  createdAtFrom?: string,
  createdAtTo?: string,
  page?: number,
  pageSize?: number,
  orderBy?: string,
  orderDirection?: 'asc' | 'desc',
  options?: { enabled?: boolean }
): UseQueryResult<WebhooksPage, Error> {
  const safePage = Number.isFinite(page ?? 0) && (page ?? 0) > 0 ? (page ?? 0) : 0
  const safePageSize =
    pageSize === -1 || (Number.isFinite(pageSize ?? 20) && (pageSize ?? 20) > 0)
      ? (pageSize ?? 20)
      : 20

  return useQuery({
    queryKey: [
      'webhooks',
      search ?? '',
      enabled ?? '',
      lastDelivery ?? '',
      createdAtFrom ?? '',
      createdAtTo ?? '',
      safePage,
      safePageSize,
      orderBy ?? '',
      orderDirection ?? ''
    ],
    queryFn: () => {
      const filters: WebhooksQuery = {}
      if (search) filters.search = search
      if (enabled === 'enabled') filters.enabled = true
      if (enabled === 'disabled') filters.enabled = false
      if (lastDelivery === 'delivered' || lastDelivery === 'failed' || lastDelivery === 'never') {
        filters.lastDelivery = lastDelivery
      }
      if (createdAtFrom) filters.createdAtFrom = createdAtFrom
      if (createdAtTo) filters.createdAtTo = createdAtTo
      if (safePageSize !== -1) {
        filters.limit = safePageSize
        filters.offset = safePage * safePageSize
      }
      if (orderBy) filters.orderBy = orderBy
      if (orderDirection) filters.orderDirection = orderDirection
      return getWebhooks(Object.keys(filters).length > 0 ? filters : undefined)
    },
    enabled: options?.enabled ?? true
  })
}

export function useWebhookOptions(): UseQueryResult<WebhooksPage, Error> {
  return useQuery({
    queryKey: ['webhooks', 'options'],
    queryFn: () => getWebhooks()
  })
}

export function useToggleWebhookEnabled() {
  const queryClient = useQueryClient()

  return useMutation({
    mutationFn: async (input: { id: string; enabled: boolean }) => {
      const result = await updateWebhook(input.id, { enabled: input.enabled })
      if (!result.success) {
        throw new Error(result.error || 'Failed to update webhook')
      }

      return result
    },
    onMutate: async (input) => {
      await queryClient.cancelQueries({ queryKey: ['webhooks'] })
      const previous = queryClient.getQueriesData<WebhooksPage>({
        queryKey: ['webhooks']
      })
      queryClient.setQueriesData<WebhooksPage>({ queryKey: ['webhooks'] }, (page) =>
        page
          ? {
              ...page,
              webhooks: page.webhooks.map((webhook) =>
                webhook.id === input.id ? { ...webhook, enabled: input.enabled } : webhook
              )
            }
          : page
      )
      return { previous }
    },
    onError: (error: Error, _input, context) => {
      for (const [queryKey, data] of context?.previous ?? []) {
        queryClient.setQueryData(queryKey, data)
      }
      toast.error(error.message || 'Failed to update webhook')
    },
    onSettled: async () => {
      await queryClient.invalidateQueries({ queryKey: ['webhooks'] })
    }
  })
}

export function useSendTestWebhook() {
  const queryClient = useQueryClient()

  return useMutation({
    mutationFn: async (id: string) => {
      const result = await sendTestWebhook(id)
      if (!result.success) {
        throw new Error(result.error || 'Test webhook failed')
      }

      return result
    },
    onSuccess: async (result) => {
      toast.success(
        result.statusCode ? `Test delivered (status ${result.statusCode})` : 'Test delivered'
      )
      await queryClient.invalidateQueries({ queryKey: ['webhook-deliveries'] })
      await queryClient.invalidateQueries({ queryKey: ['webhooks'] })
    },
    onError: async (error: Error) => {
      toast.error(error.message || 'Test webhook failed')
      await queryClient.invalidateQueries({ queryKey: ['webhook-deliveries'] })
      await queryClient.invalidateQueries({ queryKey: ['webhooks'] })
    }
  })
}

export function useWebhookSubscriptions() {
  return useQuery<WebhookSubscriptionEntry[]>({
    queryKey: ['webhook-subscriptions'],
    queryFn: () => getWebhookSubscriptions()
  })
}

export function useWebhookDeliveries(
  search?: string,
  status?: string,
  endpoint?: string,
  createdAtFrom?: string,
  createdAtTo?: string,
  page?: number,
  pageSize?: number,
  orderBy?: string,
  orderDirection?: 'asc' | 'desc'
): UseQueryResult<WebhookDeliveriesPage, Error> {
  const safePage = Number.isFinite(page ?? 0) && (page ?? 0) > 0 ? (page ?? 0) : 0
  const safePageSize =
    pageSize === -1 || (Number.isFinite(pageSize ?? 20) && (pageSize ?? 20) > 0)
      ? (pageSize ?? 20)
      : 20

  return useQuery({
    queryKey: [
      'webhook-deliveries',
      search ?? '',
      status ?? '',
      endpoint ?? '',
      createdAtFrom ?? '',
      createdAtTo ?? '',
      safePage,
      safePageSize,
      orderBy ?? '',
      orderDirection ?? ''
    ],
    queryFn: () => {
      const filters: WebhookDeliveriesQuery = {}
      if (search) filters.search = search
      if (status === 'success') filters.success = true
      if (status === 'failed') filters.success = false
      if (endpoint) filters.webhookId = endpoint
      if (createdAtFrom) filters.createdAtFrom = createdAtFrom
      if (createdAtTo) filters.createdAtTo = createdAtTo
      if (safePageSize !== -1) {
        filters.limit = safePageSize
        filters.offset = safePage * safePageSize
      }
      if (orderBy) filters.orderBy = orderBy
      if (orderDirection) filters.orderDirection = orderDirection
      return getWebhookDeliveries(Object.keys(filters).length > 0 ? filters : undefined)
    }
  })
}

export function useFormSettingsList() {
  return useQuery<FormSettingsData[]>({
    queryKey: ['form-settings'],
    queryFn: () => getAllFormSettings()
  })
}