import type { ConvertColorParserDefinition, ConvertColorParserOptions } from './definition.js';
import {
  createSDTFEngine,
  SDTFEngine,
  SpecifyDesignTokenTypeName,
} from '@specifyapp/specify-design-token-format';
import { SpecifyError, specifyErrors } from '../../../errors/index.js';
import { getSdtfQuery } from '../../utils/getSdtfQuery.js';
import { DeriveBuiltInParserHandlerFromDefinition } from '../../internals/createBuiltInParserDefinition.js';
import { ParserToolbox } from '../../../parsersEngine/index.js';
import { updateToken } from './updateToken.js';

export const AUTHORIZED_TOKENS: Array<SpecifyDesignTokenTypeName> = [
  'color',
  'border',
  'gradient',
  'gradients',
  'shadow',
  'shadows',
  'textStyle',
];

export const convertColorHandler: DeriveBuiltInParserHandlerFromDefinition<
  ConvertColorParserDefinition
> = async (previousDataBox, toolbox, parserOptions, _, _context) => {
  let sdtfEngine: SDTFEngine;

  switch (previousDataBox.type) {
    case 'SDTF': {
      sdtfEngine = createSDTFEngine(previousDataBox.graph, previousDataBox.metadata);
      break;
    }
    case 'SDTF Engine': {
      sdtfEngine = previousDataBox.engine;
      break;
    }
    default: {
      throw new SpecifyError({
        errorKey: specifyErrors.PARSERS_ENGINE_INVALID_PARSER_INPUT.errorKey,
        publicMessage: `${
          (previousDataBox as any).type
        } is not a valid input for the convert-color parser.`,
      });
    }
  }

  convertColorInner(sdtfEngine, parserOptions, toolbox);

  return {
    type: 'SDTF Engine',
    engine: sdtfEngine,
  };
};

export function convertColorInner(
  engine: SDTFEngine,
  options: ConvertColorParserOptions,
  toolbox: ParserToolbox,
) {
  const query = getSdtfQuery(options.applyTo, {
    authorizedTokens: AUTHORIZED_TOKENS,
    tokensOnly: true,
  });

  engine.query.run(query).forEach(token => {
    if (!token.isToken) return;

    if (!AUTHORIZED_TOKENS.includes(token.type)) return;

    updateToken(token, options.toFormat, toolbox);
  });
}