import { ACTION_STEPS, BuiltinActionType, ToolNotFoundError, createStore, extractToolResult, } from '@openuidev/lang-core';
import { Fragment, useCallback, useEffect, useMemo, useRef, useState, } from '@lynx-js/react';
import { OpenUIContext, useOpenUI, useRenderNode } from './context.jsx';
import { useOpenUIState } from './hooks/useOpenUIState.js';
import { keyFrom } from './utils.js';
import './renderer.css';
function isElementNode(value) {
    return (typeof value === 'object'
        && value !== null
        && 'type' in value
        && 'typeName' in value
        && value['type'] === 'element');
}
function createFieldEntry(value, componentType) {
    return componentType === undefined ? { value } : { value, componentType };
}
function isFieldEntry(value) {
    return (typeof value === 'object'
        && value !== null
        && !Array.isArray(value)
        && 'value' in value);
}
function isFieldMap(value) {
    return (typeof value === 'object'
        && value !== null
        && !Array.isArray(value)
        && Object.values(value).every((entry) => isFieldEntry(entry)));
}
function getFieldEntry(state, formName, name) {
    if (!formName) {
        const value = state[name];
        return isFieldEntry(value) ? value : undefined;
    }
    const formValue = state[formName];
    if (!isFieldMap(formValue))
        return undefined;
    return formValue[name];
}
function renderDeep(value) {
    if (value === null || value === undefined)
        return null;
    if (typeof value === 'string' || typeof value === 'number'
        || typeof value === 'boolean') {
        return <text>{String(value)}</text>;
    }
    if (Array.isArray(value)) {
        const occurrences = new Map();
        return value.map((v, i) => {
            const identity = keyFrom(v, i);
            const occurrence = occurrences.get(identity) ?? 0;
            occurrences.set(identity, occurrence + 1);
            return (<Fragment key={`${identity}:${occurrence}`}>{renderDeep(v)}</Fragment>);
        });
    }
    if (isElementNode(value)) {
        const stableKey = value.statementId ?? keyFrom(value);
        return <RenderNode key={stableKey} node={value}/>;
    }
    return null;
}
function RenderNode({ node }) {
    const { library, reportError } = useOpenUI();
    const Comp = library.components[node.typeName]?.component;
    if (!Comp)
        return null;
    try {
        return <RenderNodeInner el={node} Comp={Comp}/>;
    }
    catch (error) {
        reportError?.({
            source: 'runtime',
            code: 'render-error',
            component: node.typeName,
            message: `Component ${node.typeName} render failed: ${error instanceof Error ? error.message : String(error)}`,
        });
        return null;
    }
}
function RenderNodeInner({ el, Comp }) {
    const renderNode = useRenderNode();
    return (<Comp props={el.props} renderNode={renderNode} {...(el.statementId ? { statementId: el.statementId } : {})}/>);
}
function DefaultQueryLoader() {
    return (<view className='OpenUIQueryLoader'>
      <view className='OpenUIQueryLoaderDot'/>
    </view>);
}
function RuntimeOpenUiRenderer({ response, library, isStreaming = false, onAction, onStateUpdate, initialState, initialQueryResults, onParseResult, toolProvider, queryLoader, onError, }) {
    const onParseResultRef = useRef(onParseResult);
    onParseResultRef.current = onParseResult;
    const toolProviderInputRef = useRef(toolProvider);
    toolProviderInputRef.current = toolProvider;
    const stableToolProvider = useRef({
        async callTool(toolName, args) {
            const current = toolProviderInputRef.current ?? null;
            if (current === null) {
                throw new Error('[openui] toolProvider is null');
            }
            if (typeof current.callTool === 'function') {
                const result = await current.callTool({
                    name: toolName,
                    arguments: args,
                });
                return extractToolResult(result);
            }
            const map = current;
            const fn = map[toolName];
            if (!fn)
                throw new ToolNotFoundError(toolName, Object.keys(map));
            return await fn(args);
        },
    });
    const resolvedToolProvider = toolProvider !== null && toolProvider !== undefined
        ? stableToolProvider.current
        : null;
    const stateOptions = {
        response,
        library,
        isStreaming,
        toolProvider: resolvedToolProvider,
        ...(onAction ? { onAction } : {}),
        ...(onStateUpdate ? { onStateUpdate } : {}),
        ...(initialState ? { initialState } : {}),
        ...(initialQueryResults ? { initialQueryResults } : {}),
        ...(onError ? { onError } : {}),
    };
    const { result, parseResult, contextValue, isQueryLoading } = useOpenUIState(stateOptions, renderDeep);
    useEffect(() => {
        onParseResultRef.current?.(parseResult);
    }, [parseResult]);
    if (!result?.root)
        return null;
    return (<OpenUIContext.Provider value={contextValue}>
      <view className='OpenUIRenderer'>
        {isQueryLoading ? (queryLoader ?? <DefaultQueryLoader />) : null}
        <view className={isQueryLoading
            ? 'OpenUIRendererContent OpenUIRendererContentLoading'
            : 'OpenUIRendererContent'}>
          <RenderNode node={result.root}/>
        </view>
      </view>
    </OpenUIContext.Provider>);
}
function ParsedOpenUiRenderer({ result, library, onAction, isStreaming = false, }) {
    const [formState, setFormState] = useState({});
    const formStateRef = useRef(formState);
    const onActionRef = useRef(onAction);
    const store = useMemo(() => createStore(), []);
    useEffect(() => {
        formStateRef.current = formState;
    }, [formState]);
    useEffect(() => {
        onActionRef.current = onAction;
    }, [onAction]);
    useEffect(() => {
        return () => store.dispose();
    }, [store]);
    const getFieldValue = useCallback((formName, name) => {
        return getFieldEntry(formStateRef.current, formName, name)?.value;
    }, [formStateRef]);
    const setFieldValue = useCallback((formName, componentType, name, value, _shouldTriggerSaveCallback = true) => {
        const currentState = formStateRef.current;
        const newState = { ...currentState };
        if (formName) {
            const currentFormValue = currentState[formName];
            newState[formName] = {
                ...(isFieldMap(currentFormValue) ? currentFormValue : {}),
                [name]: createFieldEntry(value, componentType),
            };
        }
        else {
            newState[name] = createFieldEntry(value, componentType);
            store.set(name, value);
        }
        setFormState(newState);
        formStateRef.current = newState;
    }, [formStateRef, setFormState, store]);
    const triggerAction = useCallback((userMessage, formName, action) => {
        const currentState = formStateRef.current;
        const handler = onActionRef.current;
        // ActionPlan path (v0.5) — sequential steps
        if (action && 'steps' in action) {
            let relevantState;
            const formValue = formName ? currentState[formName] : undefined;
            if (formName && formValue !== undefined) {
                relevantState = { [formName]: formValue };
            }
            else if (Object.keys(currentState).length > 0) {
                relevantState = currentState;
            }
            for (const step of action.steps) {
                switch (step.type) {
                    case ACTION_STEPS.ToAssistant:
                        handler?.({
                            type: BuiltinActionType.ContinueConversation,
                            params: step.context ? { context: step.context } : {},
                            humanFriendlyMessage: step.message,
                            ...(relevantState ? { formState: relevantState } : {}),
                            ...(formName ? { formName } : {}),
                        });
                        break;
                    case ACTION_STEPS.OpenUrl:
                        handler?.({
                            type: BuiltinActionType.OpenUrl,
                            params: { url: step.url },
                            humanFriendlyMessage: '',
                            ...(relevantState ? { formState: relevantState } : {}),
                            ...(formName ? { formName } : {}),
                        });
                        break;
                    case ACTION_STEPS.Run:
                    case ACTION_STEPS.Set:
                    case ACTION_STEPS.Reset:
                        // OpenUiRenderer does not own the query manager, store, or
                        // evaluation context needed to execute these steps. Report them
                        // explicitly so generated plans do not fail silently here.
                        console.warn(`[OpenUiRenderer] Unsupported ActionPlan step: ${step.type}`, step);
                        break;
                    default:
                        console.warn('[OpenUiRenderer] Unknown ActionPlan step:', step);
                        break;
                }
            }
            return;
        }
        const legacyAction = action && !('steps' in action)
            ? action
            : undefined;
        const actionType = legacyAction?.type
            ?? BuiltinActionType.ContinueConversation;
        const actionParams = { ...(legacyAction?.params ?? {}) };
        if (legacyAction?.url)
            actionParams['url'] = legacyAction.url;
        if (legacyAction?.context)
            actionParams['context'] = legacyAction.context;
        let relevantState;
        const formValue = formName ? currentState[formName] : undefined;
        if (formName && formValue !== undefined) {
            relevantState = { [formName]: formValue };
        }
        else if (Object.keys(currentState).length > 0) {
            relevantState = currentState;
        }
        handler?.({
            type: actionType,
            params: actionParams,
            humanFriendlyMessage: userMessage,
            ...(relevantState ? { formState: relevantState } : {}),
            ...(formName ? { formName } : {}),
        });
    }, [formStateRef, onActionRef]);
    const evaluationContext = useMemo(() => ({
        getState: (name) => getFieldValue(undefined, name),
        resolveRef: () => undefined,
    }), [getFieldValue]);
    const contextValue = useMemo(() => ({
        library,
        renderNode: renderDeep,
        triggerAction,
        isStreaming,
        isQueryLoading: false,
        getFieldValue,
        setFieldValue,
        store,
        evaluationContext,
    }), [
        library,
        triggerAction,
        isStreaming,
        getFieldValue,
        setFieldValue,
        store,
        evaluationContext,
    ]);
    if (!result?.root)
        return null;
    return (<OpenUIContext.Provider value={contextValue}>
      <RenderNode node={result.root}/>
    </OpenUIContext.Provider>);
}
/** Render OpenUI language output using a ReactLynx component library. */
export function OpenUiRenderer(props) {
    if ('response' in props) {
        return <RuntimeOpenUiRenderer {...props}/>;
    }
    return <ParsedOpenUiRenderer {...props}/>;
}
//# sourceMappingURL=renderer.jsx.map