import { useCallback, useContext, useEffect, useRef, useState } from '@byted-doubao-apps/framework';
import { warnUnsupported } from '../base/warn-unsupported.js';
import { RadioGroupRuntimeContext } from '../RadioGroup/context.js';
import { mapRadioProps, resolveLynxRadioValue, resolveStandaloneSelectedValue, shouldDispatchStandaloneRadioChange, toRadioChangeEvent } from './map.js';
import { markRuntimeRadio } from './shared.js';
function RadioImpl(props) {
    const { children, onChange, ...nonEventProps } = props;
    const { mapped, unsupported, radioId, resolvedValue, resolvedDisabled, resolvedChecked } = mapRadioProps(nonEventProps);
    const groupContext = useContext(RadioGroupRuntimeContext);
    const warnedMissingGroupValueRef = useRef(false);
    const fallbackValueRef = useRef(`__taro_runtime_radio_missing_${nextMissingValueId()}`);
    const [uncontrolledChecked, setUncontrolledChecked] = useState(resolvedChecked ?? false);
    warnUnsupported('Radio', unsupported);
    useEffect(() => {
        if (!groupContext ||
            resolvedValue !== undefined ||
            warnedMissingGroupValueRef.current ||
            isProduction()) {
            return;
        }
        warnedMissingGroupValueRef.current = true;
        // eslint-disable-next-line no-console
        console.warn('[components-taro] Radio inside RadioGroup requires a string value.');
    }, [groupContext, resolvedValue]);
    useEffect(() => {
        if (!groupContext || resolvedValue === undefined) {
            return;
        }
        return groupContext.registerRadioOnChange(resolvedValue, () => {
            onChange?.(toRadioChangeEvent({ value: resolvedValue }, 'change', radioId));
        });
    }, [groupContext, onChange, radioId, resolvedValue]);
    const valueForLynx = resolveLynxRadioValue(resolvedValue, fallbackValueRef.current);
    const handleGroupLabelTap = useCallback(() => {
        if (!groupContext || groupContext.disabled || resolvedDisabled || resolvedValue === undefined) {
            return;
        }
        groupContext.selectValue(resolvedValue);
    }, [groupContext, resolvedDisabled, resolvedValue]);
    const isStandaloneControlled = resolvedChecked !== undefined;
    const isStandaloneChecked = isStandaloneControlled ? resolvedChecked : uncontrolledChecked;
    const handleStandaloneSelect = useCallback(() => {
        if (resolvedDisabled) {
            return;
        }
        if (shouldDispatchStandaloneRadioChange(isStandaloneChecked)) {
            onChange?.(toRadioChangeEvent({ value: resolvedValue }, 'change', radioId));
        }
        if (!isStandaloneControlled && !isStandaloneChecked) {
            setUncontrolledChecked(true);
        }
    }, [isStandaloneChecked, isStandaloneControlled, onChange, radioId, resolvedDisabled, resolvedValue]);
    if (groupContext) {
        return (<view {...mapped}>
        <radio value={valueForLynx} disabled={resolvedDisabled || groupContext.disabled}/>
        {children !== undefined ? <view bindtap={handleGroupLabelTap}>{children}</view> : null}
      </view>);
    }
    const standaloneSelectedValue = resolveStandaloneSelectedValue(isStandaloneChecked ?? false, valueForLynx);
    const lynxStandaloneGroupProps = {
        disabled: resolvedDisabled,
        onValueChange: handleStandaloneSelect,
        ...(standaloneSelectedValue !== null ? { value: standaloneSelectedValue } : {})
    };
    return (<view {...mapped}>
      <radio-group {...lynxStandaloneGroupProps}>
        <radio value={valueForLynx} disabled={resolvedDisabled}/>
      </radio-group>
      {children !== undefined ? <view bindtap={handleStandaloneSelect}>{children}</view> : null}
    </view>);
}
export const Radio = markRuntimeRadio(RadioImpl);
let missingValueId = 0;
function nextMissingValueId() {
    const current = missingValueId;
    missingValueId += 1;
    return current;
}
function isProduction() {
    return (globalThis.process?.env?.NODE_ENV === 'production');
}
//# sourceMappingURL=index.jsx.map