import * as React from 'react';
import { useEffect, useRef, useState } from 'react';
import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js';
import { Byline } from '../../components/design-system/Byline.js';
import { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js';
import { Spinner } from '../../components/Spinner.js';
import TextInput from '../../components/TextInput.js';
import { Box, Text } from '../../ink.js';
import { toError } from '../../utils/errors.js';
import { logError } from '../../utils/log.js';
import { clearAllCaches } from '../../utils/plugins/cacheUtils.js';
import { addMarketplaceSource, saveMarketplaceToSettings } from '../../utils/plugins/marketplaceManager.js';
import { parseMarketplaceInput } from '../../utils/plugins/parseMarketplaceInput.js';
import type { ViewState } from './types.js';
type Props = {
  inputValue: string;
  setInputValue: (value: string) => void;
  cursorOffset: number;
  setCursorOffset: (offset: number) => void;
  error: string | null;
  setError: (error: string | null) => void;
  result: string | null;
  setResult: (result: string | null) => void;
  setViewState: (state: ViewState) => void;
  onAddComplete?: () => void | Promise<void>;
  cliMode?: boolean;
};
export function AddMarketplace({
  inputValue,
  setInputValue,
  cursorOffset,
  setCursorOffset,
  error,
  setError,
  result,
  setResult,
  setViewState,
  onAddComplete,
  cliMode = false
}: Props): React.ReactNode {
  const hasAttemptedAutoAdd = useRef(false);
  const [isLoading, setLoading] = useState(false);
  const [progressMessage, setProgressMessage] = useState<string>('');
  const handleAdd = async () => {
    const input = inputValue.trim();
    if (!input) {
      setError('Please enter a marketplace source');
      return;
    }
    const parsed = await parseMarketplaceInput(input);
    if (!parsed) {
      setError('Invalid marketplace source format. Try: owner/repo, https://..., or ./path');
      return;
    }

    // Check if parseMarketplaceInput returned an error
    if ('error' in parsed) {
      setError(parsed.error);
      return;
    }
    setError(null);
    try {
      setLoading(true);
      setProgressMessage('');
      const {
        name,
        resolvedSource
      } = await addMarketplaceSource(parsed, message => {
        setProgressMessage(message);
      });
      saveMarketplaceToSettings(name, {
        source: resolvedSource
      });
      clearAllCaches();
      let sourceType = parsed.source;
      if (parsed.source === 'github') {
        sourceType = parsed.repo as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
      }
      logEvent('tengu_marketplace_added', {
        source_type: sourceType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
      });
      if (onAddComplete) {
        await onAddComplete();
      }
      setProgressMessage('');
      setLoading(false);
      if (cliMode) {
        // In CLI mode, set result to trigger completion
        setResult(`Successfully added marketplace: ${name}`);
      } else {
        // In interactive mode, switch to browse view
        setViewState({
          type: 'browse-marketplace',
          targetMarketplace: name
        });
      }
    } catch (err) {
      const error = toError(err);
      logError(error);
      setError(error.message);
      setProgressMessage('');
      setLoading(false);
      if (cliMode) {
        // In CLI mode, set result with error to trigger completion
        setResult(`Error: ${error.message}`);
      } else {
        setResult(null);
      }
    }
  };

  // Auto-add if inputValue is provided
  useEffect(() => {
    if (inputValue && !hasAttemptedAutoAdd.current && !error && !result) {
      hasAttemptedAutoAdd.current = true;
      void handleAdd();
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional
  }, []); // Only run once on mount

  return <Box flexDirection="column">
      <Box flexDirection="column" paddingX={1} borderStyle="round">
        <Box marginBottom={1}>
          <Text bold>Add Marketplace</Text>
        </Box>
        <Box flexDirection="column">
          <Text>Enter marketplace source:</Text>
          <Text dimColor>Examples:</Text>
          <Text dimColor> · owner/repo (GitHub)</Text>
          <Text dimColor> · git@github.com:owner/repo.git (SSH)</Text>
          <Text dimColor> · https://example.com/marketplace.json</Text>
          <Text dimColor> · ./path/to/marketplace</Text>
          <Box marginTop={1}>
            <TextInput value={inputValue} onChange={setInputValue} onSubmit={handleAdd} columns={80} cursorOffset={cursorOffset} onChangeCursorOffset={setCursorOffset} focus showCursor />
          </Box>
        </Box>
        {isLoading && <Box marginTop={1}>
            <Spinner />
            <Text>
              {progressMessage || 'Adding marketplace to configuration…'}
            </Text>
          </Box>}
        {error && <Box marginTop={1}>
            <Text color="error">{error}</Text>
          </Box>}
        {result && <Box marginTop={1}>
            <Text>{result}</Text>
          </Box>}
      </Box>
      <Box marginLeft={3}>
        <Text dimColor italic>
          <Byline>
            <KeyboardShortcutHint shortcut="Enter" action="add" />
            <ConfigurableShortcutHint action="confirm:no" context="Settings" fallback="Esc" description="cancel" />
          </Byline>
        </Text>
      </Box>
    </Box>;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useRef","useState","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","ConfigurableShortcutHint","Byline","KeyboardShortcutHint","Spinner","TextInput","Box","Text","toError","logError","clearAllCaches","addMarketplaceSource","saveMarketplaceToSettings","parseMarketplaceInput","ViewState","Props","inputValue","setInputValue","value","cursorOffset","setCursorOffset","offset","error","setError","result","setResult","setViewState","state","onAddComplete","Promise","cliMode","AddMarketplace","ReactNode","hasAttemptedAutoAdd","isLoading","setLoading","progressMessage","setProgressMessage","handleAdd","input","trim","parsed","name","resolvedSource","message","source","sourceType","repo","source_type","type","targetMarketplace","err","current"],"sources":["AddMarketplace.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useRef, useState } from 'react'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js'\nimport { Spinner } from '../../components/Spinner.js'\nimport TextInput from '../../components/TextInput.js'\nimport { Box, Text } from '../../ink.js'\nimport { toError } from '../../utils/errors.js'\nimport { logError } from '../../utils/log.js'\nimport { clearAllCaches } from '../../utils/plugins/cacheUtils.js'\nimport {\n  addMarketplaceSource,\n  saveMarketplaceToSettings,\n} from '../../utils/plugins/marketplaceManager.js'\nimport { parseMarketplaceInput } from '../../utils/plugins/parseMarketplaceInput.js'\nimport type { ViewState } from './types.js'\n\ntype Props = {\n  inputValue: string\n  setInputValue: (value: string) => void\n  cursorOffset: number\n  setCursorOffset: (offset: number) => void\n  error: string | null\n  setError: (error: string | null) => void\n  result: string | null\n  setResult: (result: string | null) => void\n  setViewState: (state: ViewState) => void\n  onAddComplete?: () => void | Promise<void>\n  cliMode?: boolean\n}\n\nexport function AddMarketplace({\n  inputValue,\n  setInputValue,\n  cursorOffset,\n  setCursorOffset,\n  error,\n  setError,\n  result,\n  setResult,\n  setViewState,\n  onAddComplete,\n  cliMode = false,\n}: Props): React.ReactNode {\n  const hasAttemptedAutoAdd = useRef(false)\n  const [isLoading, setLoading] = useState(false)\n  const [progressMessage, setProgressMessage] = useState<string>('')\n\n  const handleAdd = async () => {\n    const input = inputValue.trim()\n    if (!input) {\n      setError('Please enter a marketplace source')\n      return\n    }\n\n    const parsed = await parseMarketplaceInput(input)\n    if (!parsed) {\n      setError(\n        'Invalid marketplace source format. Try: owner/repo, https://..., or ./path',\n      )\n      return\n    }\n\n    // Check if parseMarketplaceInput returned an error\n    if ('error' in parsed) {\n      setError(parsed.error)\n      return\n    }\n\n    setError(null)\n\n    try {\n      setLoading(true)\n      setProgressMessage('')\n      const { name, resolvedSource } = await addMarketplaceSource(\n        parsed,\n        message => {\n          setProgressMessage(message)\n        },\n      )\n      saveMarketplaceToSettings(name, { source: resolvedSource })\n      clearAllCaches()\n\n      let sourceType = parsed.source\n      if (parsed.source === 'github') {\n        sourceType =\n          parsed.repo as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS\n      }\n\n      logEvent('tengu_marketplace_added', {\n        source_type:\n          sourceType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      if (onAddComplete) {\n        await onAddComplete()\n      }\n\n      setProgressMessage('')\n      setLoading(false)\n\n      if (cliMode) {\n        // In CLI mode, set result to trigger completion\n        setResult(`Successfully added marketplace: ${name}`)\n      } else {\n        // In interactive mode, switch to browse view\n        setViewState({ type: 'browse-marketplace', targetMarketplace: name })\n      }\n    } catch (err) {\n      const error = toError(err)\n      logError(error)\n      setError(error.message)\n      setProgressMessage('')\n      setLoading(false)\n\n      if (cliMode) {\n        // In CLI mode, set result with error to trigger completion\n        setResult(`Error: ${error.message}`)\n      } else {\n        setResult(null)\n      }\n    }\n  }\n\n  // Auto-add if inputValue is provided\n  useEffect(() => {\n    if (inputValue && !hasAttemptedAutoAdd.current && !error && !result) {\n      hasAttemptedAutoAdd.current = true\n      void handleAdd()\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  }, []) // Only run once on mount\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box flexDirection=\"column\" paddingX={1} borderStyle=\"round\">\n        <Box marginBottom={1}>\n          <Text bold>Add Marketplace</Text>\n        </Box>\n        <Box flexDirection=\"column\">\n          <Text>Enter marketplace source:</Text>\n          <Text dimColor>Examples:</Text>\n          <Text dimColor> · owner/repo (GitHub)</Text>\n          <Text dimColor> · git@github.com:owner/repo.git (SSH)</Text>\n          <Text dimColor> · https://example.com/marketplace.json</Text>\n          <Text dimColor> · ./path/to/marketplace</Text>\n          <Box marginTop={1}>\n            <TextInput\n              value={inputValue}\n              onChange={setInputValue}\n              onSubmit={handleAdd}\n              columns={80}\n              cursorOffset={cursorOffset}\n              onChangeCursorOffset={setCursorOffset}\n              focus\n              showCursor\n            />\n          </Box>\n        </Box>\n        {isLoading && (\n          <Box marginTop={1}>\n            <Spinner />\n            <Text>\n              {progressMessage || 'Adding marketplace to configuration…'}\n            </Text>\n          </Box>\n        )}\n        {error && (\n          <Box marginTop={1}>\n            <Text color=\"error\">{error}</Text>\n          </Box>\n        )}\n        {result && (\n          <Box marginTop={1}>\n            <Text>{result}</Text>\n          </Box>\n        )}\n      </Box>\n      <Box marginLeft={3}>\n        <Text dimColor italic>\n          <Byline>\n            <KeyboardShortcutHint shortcut=\"Enter\" action=\"add\" />\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Settings\"\n              fallback=\"Esc\"\n              description=\"cancel\"\n            />\n          </Byline>\n        </Text>\n      </Box>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}