import type { ChildChunkDetail, ChildSegmentsResponse, SegmentDetailModel, SegmentUpdater } from '@/models/datasets'
import { toast } from '@langgenius/dify-ui/toast'
import { useQueryClient } from '@tanstack/react-query'
import { useCallback, useEffect, useMemo, useRef } from 'react'
import { useTranslation } from 'react-i18next'
import { useEventEmitterContextContext } from '@/context/event-emitter'
import { useChildSegmentList, useChildSegmentListKey, useDeleteChildSegment, useUpdateChildSegment } from '@/service/knowledge/use-segment'
import { useInvalid } from '@/service/use-base'
import { useDocumentContext } from '../../context'

type UseChildSegmentDataOptions = {
  searchValue: string
  currentPage: number
  limit: number
  segments: SegmentDetailModel[]
  currChunkId: string
  isFullDocMode: boolean
  onCloseChildSegmentDetail: () => void
  refreshChunkListDataWithDetailChanged: () => void
  updateSegmentInCache: (segmentId: string, updater: (seg: SegmentDetailModel) => SegmentDetailModel) => void
}
type UseChildSegmentDataReturn = {
  childSegments: ChildChunkDetail[]
  isLoadingChildSegmentList: boolean
  childChunkListData: ReturnType<typeof useChildSegmentList>['data']
  childSegmentListRef: React.RefObject<HTMLDivElement | null>
  needScrollToBottom: React.RefObject<boolean>
  // Operations
  onDeleteChildChunk: (segmentId: string, childChunkId: string) => Promise<void>
  handleUpdateChildChunk: (segmentId: string, childChunkId: string, content: string) => Promise<void>
  onSaveNewChildChunk: (newChildChunk?: ChildChunkDetail) => void
  resetChildList: () => void
  viewNewlyAddedChildChunk: () => void
}
export const useChildSegmentData = (options: UseChildSegmentDataOptions): UseChildSegmentDataReturn => {
  const { searchValue, currentPage, limit, segments, currChunkId, isFullDocMode, onCloseChildSegmentDetail, refreshChunkListDataWithDetailChanged, updateSegmentInCache } = options
  const { t } = useTranslation()
  const { eventEmitter } = useEventEmitterContextContext()
  const queryClient = useQueryClient()
  const datasetId = useDocumentContext(s => s.datasetId) || ''
  const documentId = useDocumentContext(s => s.documentId) || ''
  const parentMode = useDocumentContext(s => s.parentMode)
  const childSegmentListRef = useRef<HTMLDivElement>(null)
  const needScrollToBottom = useRef(false)
  // Build query params
  const queryParams = useMemo(() => ({
    page: currentPage === 0 ? 1 : currentPage,
    limit,
    keyword: searchValue,
  }), [currentPage, limit, searchValue])
  const segmentId = segments[0]?.id || ''
  // Build query key for optimistic updates
  const currentQueryKey = useMemo(() => [...useChildSegmentListKey, datasetId, documentId, segmentId, queryParams], [datasetId, documentId, segmentId, queryParams])
  // Fetch child segment list
  const { isLoading: isLoadingChildSegmentList, data: childChunkListData } = useChildSegmentList({
    datasetId,
    documentId,
    segmentId,
    params: queryParams,
  }, !isFullDocMode || segments.length === 0)
  // Derive child segments from query data
  const childSegments = useMemo(() => childChunkListData?.data || [], [childChunkListData])
  const invalidChildSegmentList = useInvalid(useChildSegmentListKey)
  // Scroll to bottom when child segments change
  useEffect(() => {
    if (childSegmentListRef.current && needScrollToBottom.current) {
      childSegmentListRef.current.scrollTo({ top: childSegmentListRef.current.scrollHeight, behavior: 'smooth' })
      needScrollToBottom.current = false
    }
  }, [childSegments])
  const resetChildList = useCallback(() => {
    invalidChildSegmentList()
  }, [invalidChildSegmentList])
  // Optimistic update helper for child segments
  const updateChildSegmentInCache = useCallback((childChunkId: string, updater: (chunk: ChildChunkDetail) => ChildChunkDetail) => {
    queryClient.setQueryData<ChildSegmentsResponse>(currentQueryKey, (old) => {
      if (!old)
        return old
      return {
        ...old,
        data: old.data.map(chunk => chunk.id === childChunkId ? updater(chunk) : chunk),
      }
    })
  }, [queryClient, currentQueryKey])
  // Mutations
  const { mutateAsync: deleteChildSegment } = useDeleteChildSegment()
  const { mutateAsync: updateChildSegment } = useUpdateChildSegment()
  const onDeleteChildChunk = useCallback(async (segmentIdParam: string, childChunkId: string) => {
    await deleteChildSegment({ datasetId, documentId, segmentId: segmentIdParam, childChunkId }, {
      onSuccess: () => {
        toast.success(t('actionMsg.modifiedSuccessfully', { ns: 'common' }))
        if (parentMode === 'paragraph') {
          // Update parent segment's child_chunks in cache
          updateSegmentInCache(segmentIdParam, seg => ({
            ...seg,
            child_chunks: seg.child_chunks?.filter(chunk => chunk.id !== childChunkId),
          }))
        }
        else {
          resetChildList()
        }
      },
      onError: () => {
        toast.error(t('actionMsg.modifiedUnsuccessfully', { ns: 'common' }))
      },
    })
  }, [datasetId, documentId, parentMode, deleteChildSegment, updateSegmentInCache, resetChildList, t])
  const handleUpdateChildChunk = useCallback(async (segmentIdParam: string, childChunkId: string, content: string) => {
    const params: SegmentUpdater = { content: '' }
    if (!content.trim()) {
      toast.error(t('segment.contentEmpty', { ns: 'datasetDocuments' }))
      return
    }
    params.content = content
    eventEmitter?.emit('update-child-segment')
    await updateChildSegment({ datasetId, documentId, segmentId: segmentIdParam, childChunkId, body: params }, {
      onSuccess: (res) => {
        toast.success(t('actionMsg.modifiedSuccessfully', { ns: 'common' }))
        onCloseChildSegmentDetail()
        if (parentMode === 'paragraph') {
          // Update parent segment's child_chunks in cache
          updateSegmentInCache(segmentIdParam, seg => ({
            ...seg,
            child_chunks: seg.child_chunks?.map(childSeg => childSeg.id === childChunkId
              ? {
                  ...childSeg,
                  content: res.data.content,
                  type: res.data.type,
                  word_count: res.data.word_count,
                  updated_at: res.data.updated_at,
                }
              : childSeg),
          }))
          refreshChunkListDataWithDetailChanged()
        }
        else {
          updateChildSegmentInCache(childChunkId, chunk => ({
            ...chunk,
            content: res.data.content,
            type: res.data.type,
            word_count: res.data.word_count,
            updated_at: res.data.updated_at,
          }))
        }
      },
      onSettled: () => {
        eventEmitter?.emit('update-child-segment-done')
      },
    })
  }, [datasetId, documentId, parentMode, updateChildSegment, eventEmitter, onCloseChildSegmentDetail, updateSegmentInCache, updateChildSegmentInCache, refreshChunkListDataWithDetailChanged, t])
  const onSaveNewChildChunk = useCallback((newChildChunk?: ChildChunkDetail) => {
    if (parentMode === 'paragraph') {
      // Update parent segment's child_chunks in cache
      updateSegmentInCache(currChunkId, seg => ({
        ...seg,
        child_chunks: [...(seg.child_chunks || []), newChildChunk!],
      }))
      refreshChunkListDataWithDetailChanged()
    }
    else {
      resetChildList()
    }
  }, [parentMode, currChunkId, updateSegmentInCache, refreshChunkListDataWithDetailChanged, resetChildList])
  const viewNewlyAddedChildChunk = useCallback(() => {
    const totalPages = childChunkListData?.total_pages || 0
    const total = childChunkListData?.total || 0
    const newPage = Math.ceil((total + 1) / limit)
    needScrollToBottom.current = true
    if (newPage > totalPages)
      return
    resetChildList()
  }, [childChunkListData, limit, resetChildList])
  return {
    childSegments,
    isLoadingChildSegmentList,
    childChunkListData,
    childSegmentListRef,
    needScrollToBottom,
    onDeleteChildChunk,
    handleUpdateChildChunk,
    onSaveNewChildChunk,
    resetChildList,
    viewNewlyAddedChildChunk,
  }
}