import { SpecifyDesignTokenTypeName, TokenState } from '@specifyapp/specify-design-token-format';
import { matchJsonValue } from '../../utils/jsonValueMatcher.js';
import { colorToSwift } from './tokenTypes/color.js';
import { borderToSwift } from './tokenTypes/border.js';
import { breakpointToSwift } from './tokenTypes/breakpoint.js';
import { cubicBezierToSwift } from './tokenTypes/cubicBezier.js';
import { dimensionToSwift } from './tokenTypes/dimension.js';
import { durationToSwift } from './tokenTypes/duration.js';
import { fontToSwift } from './tokenTypes/font.js';
import { fontWeightToSwift } from './tokenTypes/fontWeight.js';
import { gradientToSwift } from './tokenTypes/gradient.js';
import { gradientsToSwift } from './tokenTypes/gradients.js';
import { opacityToSwift } from './tokenTypes/opacity.js';
import { radiiToSwift } from './tokenTypes/radii.js';
import { radiusToSwift } from './tokenTypes/radius.js';
import { shadowToSwift } from './tokenTypes/shadow.js';
import { shadowsToSwift } from './tokenTypes/shadows.js';
import { spacingToSwift } from './tokenTypes/spacing.js';
import { spacingsToSwift } from './tokenTypes/spacings.js';
import { textAlignmentHorizontalToSwift } from './tokenTypes/textAlignHorizontal.js';
import { textStyleToSwift } from './tokenTypes/textStyle.js';
import { transitionToSwift } from './tokenTypes/transition.js';
import { dataOfToken, makeRenderer } from './template.js';

export type ConvertedOutput = { [type in SpecifyDesignTokenTypeName]?: { [name: string]: string } };

export type ConversionOutput = {
  variableName: string;
  value: string;
};

export type MultipleConversionOutput = Array<
  ConversionOutput & { type: SpecifyDesignTokenTypeName }
>;

export function convertTokens(
  tokens: Array<TokenState>,
  tokenNameTemplate: string,
): ConvertedOutput {
  const outputTokens = {} as ConvertedOutput;

  const renderVariable = makeRenderer(tokenNameTemplate);

  for (const token of tokens) {
    for (const mode of token.modes) {
      const variableName = renderVariable(
        dataOfToken(token, token.modes.length === 1 ? undefined : mode),
      );

      const wrapValue = (value: string | undefined) => {
        if (!value) return;

        return { variableName, value };
      };

      const output = matchJsonValue<ConversionOutput | MultipleConversionOutput>(
        {
          border: v => borderToSwift(v, variableName),
          breakpoint: v => wrapValue(breakpointToSwift(v)),
          color: v => wrapValue(colorToSwift(v)),
          cubicBezier: v => wrapValue(cubicBezierToSwift(v)),
          dimension: v => wrapValue(dimensionToSwift(v)),
          duration: v => wrapValue(durationToSwift(v)),
          font: v => fontToSwift(v, variableName),
          fontWeight: v => wrapValue(fontWeightToSwift(v)),
          gradient: v => wrapValue(gradientToSwift(v)),
          gradients: v => gradientsToSwift(v, variableName),
          opacity: v => wrapValue(opacityToSwift(v)),
          radii: v => radiiToSwift(v, variableName),
          radius: v => wrapValue(radiusToSwift(v)),
          shadow: v => shadowToSwift(v, variableName),
          shadows: v => shadowsToSwift(v, variableName),
          spacing: v => wrapValue(spacingToSwift(v)),
          spacings: v => spacingsToSwift(v, variableName),
          textAlignHorizontal: v => wrapValue(textAlignmentHorizontalToSwift(v)),
          textStyle: v => textStyleToSwift(v, variableName),
          transition: v => transitionToSwift(v, variableName),
        },
        () => {
          return undefined;
        },
        token,
        mode,
      );

      if (!output) continue;

      if (Array.isArray(output)) {
        for (const converted of output) {
          outputTokens[converted.type] ??= {};
          outputTokens[converted.type]![converted.variableName] = converted.value;
        }
      } else {
        outputTokens[token.type] ??= {};
        outputTokens[token.type]![output.variableName] = output.value;
      }
    }
  }

  return outputTokens;
}