import { type SDTFEngine, createSDTFEngine } from '@specifyapp/specify-design-token-format';
import { merge } from 'lodash-es';
import {
  DEFAULT_TEMPLATE,
  validateTemplate,
} from '../../shared/to-scss-mixin-text-style/template.js';
import { SpecifyError, specifyErrors } from '../../../errors/index.js';
import { convertTokens } from '../../shared/to-scss-mixin-text-style/convertTokens.js';
import { convertToCssClasses } from './convertToCssClasses.js';
import type { ToCssTextStyleParserDefinition } from './definition.js';
import { DeriveBuiltInParserHandlerFromDefinition } from '../../internals/createBuiltInParserDefinition.js';

export const toCssTextStyleHandler: DeriveBuiltInParserHandlerFromDefinition<
  ToCssTextStyleParserDefinition
> = async (previous, toolbox, parserOptions, outputOptions, _context) => {
  let sdtfEngine: SDTFEngine;

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

  if (outputOptions?.type !== 'file')
    throw new SpecifyError({
      errorKey: specifyErrors.PARSERS_ENGINE_INVALID_OUTPUT_TYPE.errorKey,
      publicMessage: `The output type ${outputOptions?.type} is not supported by the to-tailwind parser.`,
    });

  const defaultOptions = {
    tokenNameTemplate: DEFAULT_TEMPLATE,
    exclude: [],
    include: [],
    genericFamily: '',
  };

  // Will throw if template is not valid
  if (parserOptions?.tokenNameTemplate) validateTemplate(parserOptions.tokenNameTemplate);

  const finalOptions = merge(defaultOptions, parserOptions);

  if (finalOptions.exclude.length > 0 && finalOptions.include.length > 0) {
    throw new SpecifyError({
      errorKey: specifyErrors.PARSERS_ENGINE_INVALID_OPTION.errorKey,
      publicMessage: 'You cannot use both "exclude" and "include" options at the same time.',
    });
  }

  const { outputs, warningMessages } = convertTokens(
    sdtfEngine.query.getAllTokenStates(),
    finalOptions,
  );

  if (warningMessages.length > 0) {
    warningMessages.forEach(warningMessage => {
      toolbox.populateMessage(warningMessage);
    });
  }

  toolbox.populateOutput({
    type: 'files',
    files: [
      {
        path: outputOptions.filePath,
        content: {
          type: 'text',
          text: convertToCssClasses(outputs),
        },
      },
    ],
  });

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