import * as React from 'react';
import { useInterval } from 'usehooks-ts';
import { getIsRemoteMode, getIsScrollDraining } from '../../bootstrap/state.js';
import { useNotifications } from '../../context/notifications.js';
import { Text } from '@anthropic/ink';
import { getInitializationStatus, getLspServerManager } from '../../services/lsp/manager.js';
import { useSetAppState } from '../../state/AppState.js';
import { logForDebugging } from '../../utils/debug.js';
import { isEnvTruthy } from '../../utils/envUtils.js';

const LSP_POLL_INTERVAL_MS = 5000;

/**
 * Hook that polls LSP status and shows a notification when:
 * 1. Manager initialization fails
 * 2. Any LSP server enters an error state
 *
 * Also adds errors to appState.plugins.errors for /doctor display.
 *
 * Only active when ENABLE_LSP_TOOL is set.
 */
export function useLspInitializationNotification(): void {
  const { addNotification } = useNotifications();
  const setAppState = useSetAppState();
  // Lazy initializer — eager form re-evaluates isEnvTruthy on every REPL
  // render (the arg expression runs even though useState ignores it after
  // mount). Showed up as 7.2s isEnvTruthy self-time during PageUp spam
  // after #24498 swapped cheap !!process.env.X for isEnvTruthy().
  const [shouldPoll, setShouldPoll] = React.useState(() => isEnvTruthy('true'));
  // Track which errors we've already notified about to avoid duplicates
  const notifiedErrorsRef = React.useRef<Set<string>>(new Set());

  const addError = React.useCallback(
    (source: string, errorMessage: string) => {
      const errorKey = `${source}:${errorMessage}`;
      if (notifiedErrorsRef.current.has(errorKey)) {
        return; // Already notified
      }
      notifiedErrorsRef.current.add(errorKey);

      logForDebugging(`LSP error: ${source} - ${errorMessage}`);

      // Add error to appState.plugins.errors
      setAppState(prev => {
        // Check if this error already exists to avoid duplicates
        const existingKeys = new Set(
          prev.plugins.errors.map(e => {
            if (e.type === 'generic-error') {
              return `generic-error:${e.source}:${e.error}`;
            }
            return `${e.type}:${e.source}`;
          }),
        );

        const stateErrorKey = `generic-error:${source}:${errorMessage}`;
        if (existingKeys.has(stateErrorKey)) {
          return prev;
        }

        return {
          ...prev,
          plugins: {
            ...prev.plugins,
            errors: [
              ...prev.plugins.errors,
              {
                type: 'generic-error' as const,
                source,
                error: errorMessage,
              },
            ],
          },
        };
      });

      // Show notification - extract plugin name from source like "plugin:typescript-lsp:typescript"
      const displayName = source.startsWith('plugin:') ? (source.split(':')[1] ?? source) : source;

      addNotification({
        key: `lsp-error-${source}`,
        jsx: (
          <>
            <Text color="error">LSP for {displayName} failed</Text>
            <Text dimColor> · /plugin for details</Text>
          </>
        ),
        priority: 'medium',
        timeoutMs: 8000,
      });
    },
    [addNotification, setAppState],
  );

  const poll = React.useCallback(() => {
    if (getIsRemoteMode()) return;
    // Skip during scroll drain — iterating all LSP servers + setAppState
    // competes for the event loop with scroll frames. Next interval picks up.
    if (getIsScrollDraining()) return;

    const status = getInitializationStatus();

    // Check manager initialization status
    if (status.status === 'failed') {
      addError('lsp-manager', status.error.message);
      setShouldPoll(false);
      return;
    }

    if (status.status === 'pending' || status.status === 'not-started') {
      // Still initializing, continue polling
      return;
    }

    // Manager initialized successfully - check for server errors
    const manager = getLspServerManager();
    if (manager) {
      const servers = manager.getAllServers();
      for (const [serverName, server] of servers) {
        if (server.state === 'error' && server.lastError) {
          addError(serverName, server.lastError.message);
        }
      }
    }
    // Continue polling to detect future server errors
  }, [addError]);

  useInterval(poll, shouldPoll ? LSP_POLL_INTERVAL_MS : null);

  // Initial poll on mount
  React.useEffect(() => {
    if (getIsRemoteMode() || !shouldPoll) return;
    poll();
  }, [poll, shouldPoll]);
}