import {
  PickSpecifyDesignToken,
  SpecifyDesignTokenTypeName,
  SpecifyDimensionUnitValue,
  TokenState,
} from '@specifyapp/specify-design-token-format';
import type { KeysPerToken } from './definition.js';
import { matchRawValue } from '../../utils/rawValueMatcher.js';
import { getDimensionUpdateValue } from './tokenTypes/dimension.js';
import { getBorderUpdateValue } from './tokenTypes/border.js';
import { getRadiiUpdateValue } from './tokenTypes/radii.js';
import { getShadowUpdateValue } from './tokenTypes/shadow.js';
import { getShadowsUpdateValue } from './tokenTypes/shadows.js';
import { getTextStyleUpdateValue } from './tokenTypes/textStyle.js';
import { ParserToolbox } from '../../../parsersEngine/ParserToolbox.js';

export type BaseValue = {
  rem?: number;
};

export type options = {
  targetUnit: SpecifyDimensionUnitValue;
  excludeFormats: Array<SpecifyDimensionUnitValue> | undefined;
  includeFormats: Array<SpecifyDimensionUnitValue> | undefined;
  baseValue: BaseValue;
  applyToKeys: KeysPerToken;
};

export function updateToken(token: TokenState, options: options, toolbox: ParserToolbox) {
  token
    .getStatefulValueResult()
    .resolveDeepValue()
    .mapTopLevelValue(value =>
      value.resolveDeepValue().mapRawValueWithTokenState((value, mode, tokenState) => {
        const output = matchRawValue<
          | undefined
          | PickSpecifyDesignToken<SpecifyDesignTokenTypeName, string, true, false>['$value']
        >(
          {
            border: border =>
              getBorderUpdateValue(
                border,
                options,
                tokenState as TokenState<'border'>,
                mode,
                toolbox,
                options.applyToKeys.border,
              ),
            shadow: v =>
              getShadowUpdateValue(
                v,
                options,
                tokenState as TokenState<'shadow'>,
                mode,
                toolbox,
                options.applyToKeys.shadow,
              ),
            shadows: v =>
              getShadowsUpdateValue(
                v,
                options,
                tokenState as TokenState<'shadows'>,
                mode,
                toolbox,
                options.applyToKeys.shadow,
              ),
            textStyle: v =>
              getTextStyleUpdateValue(
                v,
                options,
                tokenState as TokenState<'textStyle'>,
                mode,
                toolbox,
                options.applyToKeys.textStyle,
              ),
            dimension: v => getDimensionUpdateValue(v, options, toolbox),
            spacing: v => getDimensionUpdateValue(v, options, toolbox),
            blur: v => getDimensionUpdateValue(v, options, toolbox),
            breakpoint: v => getDimensionUpdateValue(v, options, toolbox),
            radius: v => getDimensionUpdateValue(v, options, toolbox),
            radii: v => getRadiiUpdateValue(v, options, toolbox),
            spacings: v => getRadiiUpdateValue(v, options, toolbox),
          },
          _ => {
            throw new Error('Unreachable: invalid tokens are supposed to be filter before');
          },
          token.type,
          value,
        );

        // It means that the dimension was an alias and has been updated before
        if (!output) return;

        tokenState.updateModeValue(mode, output);
      }),
    );
}