/**
 * Shared state machine + install helper for plugin-recommendation hooks
 * (LSP, claude-code-hint). Centralizes the gate chain, async-guard,
 * and success/failure notification JSX so new sources stay small.
 */

import figures from 'figures'
import * as React from 'react'
import { getIsRemoteMode } from '../bootstrap/state.js'
import type { useNotifications } from '../context/notifications.js'
import { Text } from '@anthropic/ink'
import { logError } from '../utils/log.js'
import { getPluginById } from '../utils/plugins/marketplaceManager.js'

type AddNotification = ReturnType<typeof useNotifications>['addNotification']
type PluginData = NonNullable<Awaited<ReturnType<typeof getPluginById>>>

/**
 * Call tryResolve inside a useEffect; it applies standard gates (remote
 * mode, already-showing, in-flight) then runs resolve(). Non-null return
 * becomes the recommendation. Include tryResolve in effect deps — its
 * identity tracks recommendation, so clearing re-triggers resolution.
 */
export function usePluginRecommendationBase<T>(): {
  recommendation: T | null
  clearRecommendation: () => void
  tryResolve: (resolve: () => Promise<T | null>) => void
} {
  const [recommendation, setRecommendation] = React.useState<T | null>(null)
  const isCheckingRef = React.useRef(false)

  const tryResolve = React.useCallback(
    (resolve: () => Promise<T | null>) => {
      if (getIsRemoteMode()) return
      if (recommendation) return
      if (isCheckingRef.current) return

      isCheckingRef.current = true
      void resolve()
        .then(rec => {
          if (rec) setRecommendation(rec)
        })
        .catch(logError)
        .finally(() => {
          isCheckingRef.current = false
        })
    },
    [recommendation],
  )

  const clearRecommendation = React.useCallback(
    () => setRecommendation(null),
    [],
  )

  return { recommendation, clearRecommendation, tryResolve }
}

/** Look up plugin, run install(), emit standard success/failure notification. */
export async function installPluginAndNotify(
  pluginId: string,
  pluginName: string,
  keyPrefix: string,
  addNotification: AddNotification,
  install: (pluginData: PluginData) => Promise<void>,
): Promise<void> {
  try {
    const pluginData = await getPluginById(pluginId)
    if (!pluginData) {
      throw new Error(`Plugin ${pluginId} not found in marketplace`)
    }
    await install(pluginData)
    addNotification({
      key: `${keyPrefix}-installed`,
      jsx: (
        <Text color="success">
          {figures.tick} {pluginName} installed · restart to apply
        </Text>
      ),
      priority: 'immediate',
      timeoutMs: 5000,
    })
  } catch (error) {
    logError(error)
    addNotification({
      key: `${keyPrefix}-install-failed`,
      jsx: <Text color="error">Failed to install {pluginName}</Text>,
      priority: 'immediate',
      timeoutMs: 5000,
    })
  }
}