import type { AgentNodeType } from '../nodes/agent/types'
import type { DataSourceNodeType } from '../nodes/data-source/types'
import type { KnowledgeBaseNodeType } from '../nodes/knowledge-base/types'
import type { KnowledgeRetrievalNodeType } from '../nodes/knowledge-retrieval/types'
import type { ToolNodeType } from '../nodes/tool/types'
import type { PluginTriggerNodeType } from '../nodes/trigger-plugin/types'
import type {
  CommonEdgeType,
  CommonNodeType,
  Edge,
  ModelConfig,
  Node,
  ValueSelector,
} from '../types'
import type { ModelItem } from '@/app/components/header/account-setting/model-provider-page/declarations'
import type { Emoji } from '@/app/components/tools/types'
import type { DataSet } from '@/models/datasets'
import type { I18nKeysWithPrefix } from '@/types/i18n'
import { toast } from '@langgenius/dify-ui/toast'
import { useQueries, useQueryClient } from '@tanstack/react-query'
import isDeepEqual from 'fast-deep-equal'
import { useCallback, useEffect, useMemo, useRef } from 'react'
import { useTranslation } from 'react-i18next'
import { useEdges, useStoreApi } from 'reactflow'
import { useStore as useAppStore } from '@/app/components/app/store'
import { ModelTypeEnum } from '@/app/components/header/account-setting/model-provider-page/declarations'
import { useModelList } from '@/app/components/header/account-setting/model-provider-page/hooks'
import { normalizeModelProviderModelsResponse } from '@/app/components/header/account-setting/model-provider-page/utils'
import useNodes from '@/app/components/workflow/store/workflow/use-nodes'
import { MAX_TREE_DEPTH } from '@/config'
import { useGetLanguage } from '@/context/i18n'
import { useProviderContextSelector } from '@/context/provider-context'
import { consoleQuery } from '@/service/client'
import { fetchDatasets } from '@/service/datasets'
import { useStrategyProviders } from '@/service/use-strategy'
import {
  useAllBuiltInTools,
  useAllCustomTools,
  useAllMCPTools,
  useAllWorkflowTools,
} from '@/service/use-tools'
import { useAllTriggerPlugins } from '@/service/use-triggers'
import { AppModeEnum } from '@/types/app'
import { FlowType } from '@/types/common'
import { CUSTOM_NODE } from '../constants'
import { useDatasetsDetailStore } from '../datasets-detail-store/store'
import { useGetToolIcon, useNodesMetaData } from '../hooks'
import { useHooksStore } from '../hooks-store/store'
import { getNodeUsedVars, isSpecialVar } from '../nodes/_base/components/variable/utils'
import { hasValidInlineAgentBinding, isAgentV2NodeData } from '../nodes/agent-v2/types'
import { IndexMethodEnum } from '../nodes/knowledge-base/types'
import {
  getLLMModelIssue,
  isLLMModelProviderInstalled,
  LLMModelIssueCode,
} from '../nodes/llm/utils'
import { useStore, useWorkflowStore } from '../store'
import { BlockEnum } from '../types'
import {
  getDataSourceCheckParams,
  getNodeCatalogType,
  getToolCheckParams,
  getValidTreeNodes,
} from '../utils'
import { extractPluginId } from '../utils/plugin'
import { isNodePluginMissing } from '../utils/plugin-install-check'
import { getTriggerCheckParams } from '../utils/trigger'
import useNodesAvailableVarList, {
  useGetNodesAvailableVarList,
} from './use-nodes-available-var-list'

export type ChecklistItem = {
  id: string
  type: BlockEnum | string
  title: string
  toolIcon?: string | Emoji
  unConnected?: boolean
  errorMessages: string[]
  canNavigate: boolean
  disableGoTo?: boolean
  isPluginMissing?: boolean
  pluginUniqueIdentifier?: string
}

type CheckValidExtraData = Record<string, unknown> | undefined

const withFlowType = (moreDataForCheckValid: CheckValidExtraData, flowType?: FlowType) => {
  if (!flowType) return moreDataForCheckValid

  return {
    ...(moreDataForCheckValid ?? {}),
    flowType,
  }
}

const START_NODE_TYPES: BlockEnum[] = [
  BlockEnum.Start,
  BlockEnum.TriggerSchedule,
  BlockEnum.TriggerWebhook,
  BlockEnum.TriggerPlugin,
]

const getDuplicateEndOutputMessages = (
  nodes: Node[],
  t: ReturnType<typeof useTranslation>['t'],
) => {
  const variableOccurrences = new Map<string, string[]>()

  nodes.forEach((node) => {
    if (node.type !== CUSTOM_NODE || node.data.type !== BlockEnum.End) return

    const outputs = (node.data as { outputs?: Array<{ variable?: string }> }).outputs || []
    outputs.forEach((output) => {
      const variable = output.variable?.trim()
      if (!variable) return

      const occurrences = variableOccurrences.get(variable) || []
      occurrences.push(node.id)
      variableOccurrences.set(variable, occurrences)
    })
  })

  const nodeMessages = new Map<string, string[]>()
  variableOccurrences.forEach((nodeIds, variable) => {
    if (nodeIds.length <= 1) return

    Array.from(new Set(nodeIds)).forEach((nodeId) => {
      const messages = nodeMessages.get(nodeId) || []
      messages.push(t(($) => $['errorMsg.duplicateOutputVariable'], { ns: 'workflow', variable }))
      nodeMessages.set(nodeId, messages)
    })
  })

  return nodeMessages
}

export const useChecklist = (nodes: Node[], edges: Edge[], options?: { flowType?: FlowType }) => {
  const { t } = useTranslation()
  const language = useGetLanguage()
  const { nodesMap: nodesExtraData } = useNodesMetaData()
  const { data: buildInTools } = useAllBuiltInTools()
  const { data: customTools } = useAllCustomTools()
  const { data: workflowTools } = useAllWorkflowTools()
  const { data: mcpTools } = useAllMCPTools()
  const dataSourceList = useStore((s) => s.dataSourceList)
  const { data: strategyProviders } = useStrategyProviders()
  const { data: triggerPlugins } = useAllTriggerPlugins()
  const datasetsDetail = useDatasetsDetailStore((s) => s.datasetsDetail)
  const getToolIcon = useGetToolIcon()
  const appMode = useAppStore.getState().appDetail?.mode
  const shouldCheckStartNode =
    appMode === AppModeEnum.WORKFLOW || appMode === AppModeEnum.ADVANCED_CHAT
  const modelProviders = useProviderContextSelector((s) => s.modelProviders)
  const workflowStore = useWorkflowStore()
  const configsMap = useHooksStore((s) => s.configsMap)

  const map = useNodesAvailableVarList(nodes)
  const inlineAgentNodes = useMemo(
    () =>
      nodes.filter(
        (node) =>
          node.type === CUSTOM_NODE &&
          isAgentV2NodeData(node.data) &&
          hasValidInlineAgentBinding(node.data),
      ),
    [nodes],
  )
  const inlineAgentMissingReferences = useQueries({
    queries:
      !configsMap?.flowId ||
      (configsMap.flowType !== FlowType.appFlow && configsMap.flowType !== FlowType.snippet)
        ? []
        : inlineAgentNodes.map((node) =>
            configsMap.flowType === FlowType.snippet
              ? consoleQuery.snippets.bySnippetId.workflows.draft.nodes.byNodeId.agentComposer.get.queryOptions(
                  {
                    input: {
                      params: {
                        snippet_id: configsMap.flowId,
                        node_id: node.id,
                      },
                    },
                  },
                )
              : consoleQuery.apps.byAppId.workflows.draft.nodes.byNodeId.agentComposer.get.queryOptions(
                  {
                    input: {
                      params: {
                        app_id: configsMap.flowId,
                        node_id: node.id,
                      },
                    },
                  },
                ),
          ),
    combine: (results) => {
      const missingReferences: Record<
        string,
        { hasMissingFiles: boolean; hasMissingSkills: boolean }
      > = {}

      results.forEach((result, index) => {
        const nodeId = inlineAgentNodes[index]?.id
        const agentSoul = result.data?.agent_soul
        if (!nodeId || !agentSoul) return

        const hasMissingFiles = agentSoul.config_files?.some((file) => file.is_missing === true)
        const hasMissingSkills = agentSoul.config_skills?.some((skill) => skill.is_missing === true)
        if (!hasMissingFiles && !hasMissingSkills) return

        missingReferences[nodeId] = {
          hasMissingFiles: !!hasMissingFiles,
          hasMissingSkills: !!hasMissingSkills,
        }
      })

      return missingReferences
    },
  })
  const { data: embeddingModelList } = useModelList(ModelTypeEnum.textEmbedding)
  const { data: rerankModelList } = useModelList(ModelTypeEnum.rerank)
  const knowledgeBaseEmbeddingProviders = useMemo(() => {
    const providers = new Set<string>()

    nodes.forEach((node) => {
      if (node.type !== CUSTOM_NODE || node.data.type !== BlockEnum.KnowledgeBase) return

      const knowledgeBaseData = node.data as CommonNodeType<KnowledgeBaseNodeType>
      if (knowledgeBaseData.indexing_technique !== IndexMethodEnum.QUALIFIED) return

      const provider = knowledgeBaseData.embedding_model_provider
      if (provider) providers.add(provider)
    })

    return [...providers]
  }, [nodes])
  const knowledgeBaseProviderModelMap = useQueries({
    queries: knowledgeBaseEmbeddingProviders.map((provider) =>
      consoleQuery.workspaces.current.modelProviders.byProvider.models.get.queryOptions({
        input: { params: { provider } },
        enabled: !!provider,
        refetchOnWindowFocus: false,
        select: normalizeModelProviderModelsResponse,
      }),
    ),
    combine: (results) => {
      const modelMap: Partial<Record<string, ModelItem[]>> = {}
      knowledgeBaseEmbeddingProviders.forEach((provider, index) => {
        const models = results[index]?.data
        if (models) modelMap[provider] = models
      })
      return modelMap
    },
  })

  const getCheckData = useCallback(
    (data: CommonNodeType<{}>) => {
      let checkData = data
      if (data.type === BlockEnum.KnowledgeRetrieval) {
        const datasetIds = (data as CommonNodeType<KnowledgeRetrievalNodeType>).dataset_ids
        const _datasets = datasetIds.reduce<DataSet[]>((acc, id) => {
          if (datasetsDetail[id]) acc.push(datasetsDetail[id])
          return acc
        }, [])
        checkData = {
          ...data,
          _datasets,
        } as CommonNodeType<KnowledgeRetrievalNodeType>
      } else if (data.type === BlockEnum.KnowledgeBase) {
        const modelProviderName = (data as CommonNodeType<KnowledgeBaseNodeType>)
          .embedding_model_provider
        checkData = {
          ...data,
          _embeddingModelList: embeddingModelList,
          _embeddingProviderModelList: modelProviderName
            ? knowledgeBaseProviderModelMap[modelProviderName]
            : undefined,
          _rerankModelList: rerankModelList,
        } as CommonNodeType<KnowledgeBaseNodeType>
      }
      return checkData
    },
    [datasetsDetail, embeddingModelList, knowledgeBaseProviderModelMap, rerankModelList],
  )

  const needWarningNodes = useMemo<ChecklistItem[]>(() => {
    const list: ChecklistItem[] = []
    const filteredNodes = nodes.filter((node) => node.type === CUSTOM_NODE)
    const duplicateEndOutputMessages = getDuplicateEndOutputMessages(filteredNodes, t)
    const { validNodes } = getValidTreeNodes(filteredNodes, edges)
    const installedPluginIds = new Set(modelProviders.map((p) => extractPluginId(p.provider)))

    for (let i = 0; i < filteredNodes.length; i++) {
      const node = filteredNodes[i]
      let moreDataForCheckValid: CheckValidExtraData
      let usedVars: ValueSelector[] = []

      if (node!.data.type === BlockEnum.Tool)
        moreDataForCheckValid = getToolCheckParams(
          node!.data as ToolNodeType,
          buildInTools || [],
          customTools || [],
          workflowTools || [],
          language,
        )

      if (node!.data.type === BlockEnum.DataSource)
        moreDataForCheckValid = getDataSourceCheckParams(
          node!.data as DataSourceNodeType,
          dataSourceList || [],
          language,
        )

      if (node!.data.type === BlockEnum.TriggerPlugin)
        moreDataForCheckValid = getTriggerCheckParams(
          node!.data as PluginTriggerNodeType,
          triggerPlugins,
          language,
        )

      const toolIcon = getToolIcon(node!.data)
      if (node!.data.type === BlockEnum.Agent && !isAgentV2NodeData(node!.data)) {
        const data = node!.data as AgentNodeType
        const isReadyForCheckValid = !!strategyProviders
        const provider = strategyProviders?.find(
          (provider) => provider.declaration.identity.name === data.agent_strategy_provider_name,
        )
        const strategy = provider?.declaration.strategies?.find(
          (s) => s.identity.name === data.agent_strategy_name,
        )
        moreDataForCheckValid = {
          provider,
          strategy,
          language,
          isReadyForCheckValid,
        }
      } else {
        usedVars = getNodeUsedVars(node!).filter((v) => v.length > 0)
      }

      if (node!.type === CUSTOM_NODE) {
        const checkData = getCheckData(node!.data)
        const validator = nodesExtraData?.[getNodeCatalogType(node!.data)]?.checkValid
        const isPluginMissing = isNodePluginMissing(node!.data, {
          builtInTools: buildInTools,
          customTools,
          workflowTools,
          mcpTools,
          triggerPlugins,
          dataSourceList,
        })

        const errorMessages: string[] = []

        if (isPluginMissing) {
          errorMessages.push(t(($) => $['nodes.common.pluginNotInstalled'], { ns: 'workflow' }))
        } else {
          if (node!.data.type === BlockEnum.LLM) {
            const modelProvider = (node!.data as CommonNodeType<{ model?: ModelConfig }>).model
              ?.provider
            const modelIssue = getLLMModelIssue({
              modelProvider,
              isModelProviderInstalled: isLLMModelProviderInstalled(
                modelProvider,
                installedPluginIds,
              ),
            })
            if (modelIssue === LLMModelIssueCode.providerPluginUnavailable)
              errorMessages.push(t(($) => $['errorMsg.configureModel'], { ns: 'workflow' }))
          }

          if (validator) {
            const validationError = validator(
              checkData,
              t,
              withFlowType(moreDataForCheckValid, options?.flowType),
            ).errorMessage
            if (validationError) errorMessages.push(validationError)
          }

          const missingReferences = inlineAgentMissingReferences[node!.id]
          if (missingReferences?.hasMissingFiles)
            errorMessages.push(
              t(($) => $['agentDetail.configure.files.missing'], { ns: 'agentV2' }),
            )
          if (missingReferences?.hasMissingSkills)
            errorMessages.push(
              t(($) => $['agentDetail.configure.skills.missing'], { ns: 'agentV2' }),
            )

          const availableVars = map[node!.id]!.availableVars
          let hasInvalidVar = false
          for (const variable of usedVars) {
            if (hasInvalidVar) break
            if (isSpecialVar(variable[0]!)) continue
            const usedNode = availableVars.find((v) => v.nodeId === variable?.[0])
            if (!usedNode || !usedNode.vars.some((v) => v.variable === variable?.[1]))
              hasInvalidVar = true
          }
          if (hasInvalidVar)
            errorMessages.push(t(($) => $['errorMsg.invalidVariable'], { ns: 'workflow' }))

          errorMessages.push(...(duplicateEndOutputMessages.get(node!.id) || []))
        }

        const isStartNodeMeta =
          nodesExtraData?.[node!.data.type as BlockEnum]?.metaData.isStart ?? false
        const isStartPlaceholderNode = node!.data.type === BlockEnum.StartPlaceholder
        const canSkipConnectionCheck = shouldCheckStartNode
          ? isStartNodeMeta || isStartPlaceholderNode
          : true

        const isUnconnected = !validNodes.some((n) => n.id === node!.id)
        const shouldShowError =
          errorMessages.length > 0 || (isUnconnected && !canSkipConnectionCheck)

        if (shouldShowError) {
          list.push({
            id: node!.id,
            type: node!.data.type,
            title: node!.data.title,
            toolIcon,
            unConnected: isUnconnected && !canSkipConnectionCheck,
            errorMessages,
            canNavigate: !isPluginMissing,
            disableGoTo: isPluginMissing,
            isPluginMissing,
            pluginUniqueIdentifier: isPluginMissing
              ? (node!.data as { plugin_unique_identifier?: string }).plugin_unique_identifier
              : undefined,
          })
        }
      }
    }

    // Check for start nodes (including triggers)
    if (shouldCheckStartNode) {
      const startNodesFiltered = nodes.filter((node) =>
        START_NODE_TYPES.includes(node.data.type as BlockEnum),
      )
      const hasStartPlaceholderNode = nodes.some(
        (node) => node.data.type === BlockEnum.StartPlaceholder,
      )
      if (startNodesFiltered.length === 0 && !hasStartPlaceholderNode) {
        list.push({
          id: 'start-node-required',
          type: BlockEnum.Start,
          title: t(($) => $['panel.startNode'], { ns: 'workflow' }),
          errorMessages: [t(($) => $['common.needStartNode'], { ns: 'workflow' })],
          canNavigate: false,
        })
      }
    }

    const isRequiredNodesType = Object.keys(nodesExtraData!).filter(
      (key: any) => (nodesExtraData as any)[key].metaData.isRequired,
    )

    isRequiredNodesType.forEach((type: string) => {
      if (!filteredNodes.some((node) => node.data.type === type)) {
        list.push({
          id: `${type}-need-added`,
          type,
          title: t(($) => $[`blocks.${type}` as I18nKeysWithPrefix<'workflow', 'blocks.'>], {
            ns: 'workflow',
          }),
          errorMessages: [
            t(($) => $['common.needAdd'], {
              ns: 'workflow',
              node: t(($) => $[`blocks.${type}` as I18nKeysWithPrefix<'workflow', 'blocks.'>], {
                ns: 'workflow',
              }),
            }),
          ],
          canNavigate: false,
        })
      }
    })

    return list
  }, [
    nodes,
    edges,
    shouldCheckStartNode,
    nodesExtraData,
    buildInTools,
    customTools,
    workflowTools,
    mcpTools,
    language,
    dataSourceList,
    triggerPlugins,
    getToolIcon,
    strategyProviders,
    getCheckData,
    t,
    map,
    modelProviders,
    inlineAgentMissingReferences,
    options?.flowType,
  ])

  useEffect(() => {
    const currentChecklistItems = workflowStore.getState().checklistItems
    if (isDeepEqual(currentChecklistItems, needWarningNodes)) return

    workflowStore.setState({ checklistItems: needWarningNodes })
  }, [needWarningNodes, workflowStore])

  return needWarningNodes
}

export const useChecklistBeforePublish = () => {
  const { t } = useTranslation()
  const language = useGetLanguage()
  const queryClient = useQueryClient()
  const store = useStoreApi()
  const { nodesMap: nodesExtraData } = useNodesMetaData()
  const { data: strategyProviders } = useStrategyProviders()
  const modelProviders = useProviderContextSelector((s) => s.modelProviders)
  const updateDatasetsDetail = useDatasetsDetailStore((s) => s.updateDatasetsDetail)
  const updateTimeRef = useRef(0)
  const workflowStore = useWorkflowStore()
  const { getNodesAvailableVarList } = useGetNodesAvailableVarList()
  const { data: embeddingModelList } = useModelList(ModelTypeEnum.textEmbedding)
  const { data: rerankModelList } = useModelList(ModelTypeEnum.rerank)
  const { data: buildInTools } = useAllBuiltInTools()
  const { data: customTools } = useAllCustomTools()
  const { data: workflowTools } = useAllWorkflowTools()
  const flowType = useHooksStore((s) => s.configsMap?.flowType)
  const appMode = useAppStore.getState().appDetail?.mode
  const shouldCheckStartNode =
    appMode === AppModeEnum.WORKFLOW || appMode === AppModeEnum.ADVANCED_CHAT

  const getCheckData = useCallback(
    (
      data: CommonNodeType<object>,
      datasets: DataSet[],
      embeddingProviderModelMap?: Partial<Record<string, ModelItem[]>>,
    ) => {
      let checkData = data
      if (data.type === BlockEnum.KnowledgeRetrieval) {
        const datasetIds = (data as CommonNodeType<KnowledgeRetrievalNodeType>).dataset_ids
        const datasetsDetail = datasets.reduce<Record<string, DataSet>>((acc, dataset) => {
          acc[dataset.id] = dataset
          return acc
        }, {})
        const _datasets = datasetIds.reduce<DataSet[]>((acc, id) => {
          if (datasetsDetail[id]) acc.push(datasetsDetail[id])
          return acc
        }, [])
        checkData = {
          ...data,
          _datasets,
        } as CommonNodeType<KnowledgeRetrievalNodeType>
      } else if (data.type === BlockEnum.KnowledgeBase) {
        const modelProviderName = (data as CommonNodeType<KnowledgeBaseNodeType>)
          .embedding_model_provider
        checkData = {
          ...data,
          _embeddingModelList: embeddingModelList,
          _embeddingProviderModelList: modelProviderName
            ? embeddingProviderModelMap?.[modelProviderName]
            : undefined,
          _rerankModelList: rerankModelList,
        } as CommonNodeType<KnowledgeBaseNodeType>
      }
      return checkData
    },
    [embeddingModelList, rerankModelList],
  )

  const handleCheckBeforePublish = useCallback(async () => {
    const { getNodes, edges } = store.getState()
    const { dataSourceList } = workflowStore.getState()
    const nodes = getNodes()
    const filteredNodes = nodes.filter((node) => node.type === CUSTOM_NODE)
    const duplicateEndOutputMessages = getDuplicateEndOutputMessages(filteredNodes, t)
    const { validNodes, maxDepth } = getValidTreeNodes(filteredNodes, edges)

    if (maxDepth > MAX_TREE_DEPTH) {
      toast.error(t(($) => $['common.maxTreeDepth'], { ns: 'workflow', depth: MAX_TREE_DEPTH }))
      return false
    }

    const knowledgeBaseEmbeddingProviders = [
      ...new Set(
        filteredNodes
          .filter((node) => node.data.type === BlockEnum.KnowledgeBase)
          .map((node) => node.data as CommonNodeType<KnowledgeBaseNodeType>)
          .filter((node) => node.indexing_technique === IndexMethodEnum.QUALIFIED)
          .map((node) => node.embedding_model_provider)
          .filter((provider): provider is string => !!provider),
      ),
    ]

    const fetchKnowledgeBaseProviderModelMap = async () => {
      const modelMap: Partial<Record<string, ModelItem[]>> = {}
      await Promise.all(
        knowledgeBaseEmbeddingProviders.map(async (provider) => {
          try {
            const modelList = await queryClient.fetchQuery(
              consoleQuery.workspaces.current.modelProviders.byProvider.models.get.queryOptions({
                input: { params: { provider } },
              }),
            )

            if (modelList.data) modelMap[provider] = normalizeModelProviderModelsResponse(modelList)
          } catch {}
        }),
      )
      return modelMap
    }

    const fetchLatestDatasets = async (): Promise<DataSet[] | null> => {
      const allDatasetIds = new Set<string>()
      filteredNodes.forEach((node) => {
        if (node.data.type !== BlockEnum.KnowledgeRetrieval) return

        const datasetIds = (node.data as CommonNodeType<KnowledgeRetrievalNodeType>).dataset_ids
        datasetIds.forEach((id) => allDatasetIds.add(id))
      })

      if (allDatasetIds.size === 0) return []

      updateTimeRef.current = updateTimeRef.current + 1
      const currUpdateTime = updateTimeRef.current
      const { data: datasetsDetail } = await fetchDatasets({
        url: '/datasets',
        params: { page: 1, ids: [...allDatasetIds] },
      })
      if (currUpdateTime < updateTimeRef.current) return null
      if (datasetsDetail?.length) updateDatasetsDetail(datasetsDetail)
      return datasetsDetail || []
    }

    const [embeddingProviderModelMap, datasets] = await Promise.all([
      fetchKnowledgeBaseProviderModelMap(),
      fetchLatestDatasets(),
    ])

    if (datasets === null) return false

    const installedPluginIds = new Set(modelProviders.map((p) => extractPluginId(p.provider)))
    const map = getNodesAvailableVarList(nodes)
    for (let i = 0; i < filteredNodes.length; i++) {
      const node = filteredNodes[i]
      let moreDataForCheckValid: CheckValidExtraData
      let usedVars: ValueSelector[] = []
      if (node!.data.type === BlockEnum.Tool)
        moreDataForCheckValid = getToolCheckParams(
          node!.data as ToolNodeType,
          buildInTools || [],
          customTools || [],
          workflowTools || [],
          language,
        )

      if (node!.data.type === BlockEnum.DataSource)
        moreDataForCheckValid = getDataSourceCheckParams(
          node!.data as DataSourceNodeType,
          dataSourceList || [],
          language,
        )

      if (node!.data.type === BlockEnum.Agent && !isAgentV2NodeData(node!.data)) {
        const data = node!.data as AgentNodeType
        const isReadyForCheckValid = !!strategyProviders
        const provider = strategyProviders?.find(
          (provider) => provider.declaration.identity.name === data.agent_strategy_provider_name,
        )
        const strategy = provider?.declaration.strategies?.find(
          (s) => s.identity.name === data.agent_strategy_name,
        )
        moreDataForCheckValid = {
          provider,
          strategy,
          language,
          isReadyForCheckValid,
        }
      } else {
        usedVars = getNodeUsedVars(node!).filter((v) => v.length > 0)
      }

      if (node!.data.type === BlockEnum.LLM) {
        const modelProvider = (node!.data as CommonNodeType<{ model?: ModelConfig }>).model
          ?.provider
        const modelIssue = getLLMModelIssue({
          modelProvider,
          isModelProviderInstalled: isLLMModelProviderInstalled(modelProvider, installedPluginIds),
        })
        if (modelIssue === LLMModelIssueCode.providerPluginUnavailable) {
          toast.error(
            `[${node!.data.title}] ${t(($) => $['errorMsg.configureModel'], { ns: 'workflow' })}`,
          )
          return false
        }
      }

      const checkData = getCheckData(node!.data, datasets, embeddingProviderModelMap)
      const { errorMessage } = nodesExtraData![getNodeCatalogType(node!.data)].checkValid(
        checkData,
        t,
        withFlowType(moreDataForCheckValid, flowType),
      )

      if (errorMessage) {
        toast.error(`[${node!.data.title}] ${errorMessage}`)
        return false
      }

      const duplicateOutputMessages = duplicateEndOutputMessages.get(node!.id) || []
      if (duplicateOutputMessages.length > 0) {
        toast.error(`[${node!.data.title}] ${duplicateOutputMessages[0]}`)
        return false
      }

      const availableVars = map[node!.id]!.availableVars

      for (const variable of usedVars) {
        const isSpecialVars = isSpecialVar(variable[0]!)
        if (!isSpecialVars) {
          const usedNode = availableVars.find((v) => v.nodeId === variable?.[0])
          if (usedNode) {
            const usedVar = usedNode.vars.find((v) => v.variable === variable?.[1])
            if (!usedVar) {
              toast.error(
                `[${node!.data.title}] ${t(($) => $['errorMsg.invalidVariable'], { ns: 'workflow' })}`,
              )
              return false
            }
          } else {
            toast.error(
              `[${node!.data.title}] ${t(($) => $['errorMsg.invalidVariable'], { ns: 'workflow' })}`,
            )
            return false
          }
        }
      }

      const isStartNodeMeta =
        nodesExtraData?.[node!.data.type as BlockEnum]?.metaData.isStart ?? false
      const canSkipConnectionCheck = shouldCheckStartNode ? isStartNodeMeta : true
      const isUnconnected = !validNodes.some((n) => n.id === node!.id)

      if (isUnconnected && !canSkipConnectionCheck) {
        toast.error(
          `[${node!.data.title}] ${t(($) => $['common.needConnectTip'], { ns: 'workflow' })}`,
        )
        return false
      }
    }

    if (shouldCheckStartNode) {
      const startNodesFiltered = nodes.filter((node) =>
        START_NODE_TYPES.includes(node.data.type as BlockEnum),
      )
      if (startNodesFiltered.length === 0) {
        toast.error(t(($) => $['common.needStartNode'], { ns: 'workflow' }))
        return false
      }
    }

    const isRequiredNodesType = Object.keys(nodesExtraData!).filter(
      (key: any) => (nodesExtraData as any)[key].metaData.isRequired,
    )

    for (let i = 0; i < isRequiredNodesType.length; i++) {
      const type = isRequiredNodesType[i]

      if (!filteredNodes.some((node) => node.data.type === type)) {
        toast.error(
          t(($) => $['common.needAdd'], {
            ns: 'workflow',
            node: t(($) => $[`blocks.${type}` as I18nKeysWithPrefix<'workflow', 'blocks.'>], {
              ns: 'workflow',
            }),
          }),
        )
        return false
      }
    }

    return true
  }, [
    store,
    workflowStore,
    getNodesAvailableVarList,
    shouldCheckStartNode,
    nodesExtraData,
    t,
    updateDatasetsDetail,
    buildInTools,
    customTools,
    workflowTools,
    language,
    getCheckData,
    queryClient,
    strategyProviders,
    modelProviders,
    flowType,
  ])

  return {
    handleCheckBeforePublish,
  }
}

export const useWorkflowRunValidation = () => {
  const { t } = useTranslation()
  const nodes = useNodes()
  const edges = useEdges<CommonEdgeType>()
  const flowType = useHooksStore((s) => s.configsMap?.flowType)
  const needWarningNodes = useChecklist(nodes, edges, { flowType })

  const validateBeforeRun = useCallback(() => {
    if (needWarningNodes.length > 0) {
      toast.error(t(($) => $['panel.checklistTip'], { ns: 'workflow' }))
      return false
    }
    return true
  }, [needWarningNodes, t])

  return {
    validateBeforeRun,
    hasValidationErrors: needWarningNodes.length > 0,
    warningNodes: needWarningNodes,
  }
}