import {
  UnresolvableModeLevelAlias,
  UnresolvableTopLevelAlias,
} from '@specifyapp/specify-design-token-format';
import { makeCSSAlias } from '../../../builtInParsers/shared/to-css-custom-properties/makeCSSAlias.js';
import {
  DEFAULT_TOKEN_NOT_IN_COLLECTION_TEMPLATE,
  renderVariable as renderVariable_,
} from '../utils/template.js';
import { modeLevelUnresolvableAliasTransitonToVariables } from '../tokenTypes/transition.js';
import { modeLevelUnresolvableAliasFontToVariables } from '../tokenTypes/font.js';
import { modeLevelUnresolvableAliasTextStyleToVariables } from '../tokenTypes/textStyle.js';
import { SpecifyError, specifyErrors } from '../../../errors/index.js';
import { CssUnresolvableAliasStrategy } from './CssAliasStrategy.js';
import { TemplateRenderer } from '../../../builtInParsers/utils/template.js';

export function createUnresolvableAliasToVarStrategy(templates?: {
  tokenNotInCollectionNameTemplate?: string;
}) {
  const renderVariable: TemplateRenderer = rawData =>
    renderVariable_(
      templates?.tokenNotInCollectionNameTemplate ?? DEFAULT_TOKEN_NOT_IN_COLLECTION_TEMPLATE,
      rawData,
    );

  const strategy = ((tokenState, alias) => {
    if (alias instanceof UnresolvableTopLevelAlias) {
      throw new SpecifyError({
        publicMessage: `Converting unresolvable top level aliases is not supported yet`,
        errorKey: specifyErrors.UNEXPECTED_ERROR.errorKey,
      });
    }

    const token = alias.targetPath.at(alias.targetPath.length - 1)!;
    const groups = alias.targetPath.toArray().slice(0, alias.targetPath.length - 1);

    if (alias instanceof UnresolvableModeLevelAlias) {
      return tokenState.matchByType<Record<string, string> | string>(
        {
          transition: _ => modeLevelUnresolvableAliasTransitonToVariables(alias, renderVariable),
          font: _ => modeLevelUnresolvableAliasFontToVariables(alias, renderVariable),
          textStyle: _ => modeLevelUnresolvableAliasTextStyleToVariables(alias, renderVariable),
        },
        _ =>
          makeCSSAlias(
            renderVariable({
              token,
              groups,
              groupList: groups,
              path: groups,
              collection: undefined,
              groupsBeforeCollection: [],
              groupsAfterCollection: [],
              mode: alias.targetMode,
            }),
          ),
      );
    } else {
      // Font key in text style token
      if (alias.valuePath.at(0) === 'font') {
        return modeLevelUnresolvableAliasFontToVariables(alias, renderVariable);
      }

      return makeCSSAlias(
        renderVariable({
          token,
          groups,
          groupList: groups,
          path: groups,
          collection: undefined,
          groupsBeforeCollection: [],
          groupsAfterCollection: [],
          mode: alias.targetMode,
        }),
      );
    }
  }) as CssUnresolvableAliasStrategy<string | Record<string, string>>;

  return strategy;
}