import {
  createSDTFEngine,
  SpecifyDesignTokenFormat,
  SpecifyFontValue,
} from '@specifyapp/specify-design-token-format';
import { specifyErrors } from '../../../errors/index.js';
import { ParserToolbox, AssetDataBox } from '../../../parsersEngine/index.js';

type PartialUrlAssets = Array<Pick<AssetDataBox['assets'][number], 'url' | 'format' | 'provider'>>;

function unwrapFilesValue(files: SpecifyFontValue['files']) {
  return files.map(file => {
    return {
      url: file.url,
      format: file.format,
      provider: file.provider,
    };
  });
}

export function generateUrlDataBoxFiles(tokens: SpecifyDesignTokenFormat, toolbox: ParserToolbox) {
  const sdtfEngine = createSDTFEngine(tokens);
  const assetsTokens = sdtfEngine.query.run({
    where: {
      token: '.*?',
      withTypes: {
        include: ['bitmap', 'font', 'vector', 'textStyle', 'vectors', 'bitmaps'],
      },
      select: {
        token: true,
      },
    },
  });

  return assetsTokens.reduce(
    (acc, tokenState) => {
      if (!tokenState.isToken) {
        return acc;
      }

      if (!tokenState.isFullyResolvable) {
        toolbox.populateMessage({
          type: 'warning',
          content: `The token ${tokenState.name} is not resolvable.`,
          errorKey: specifyErrors.PARSERS_ENGINE_PARSER_EXECUTION_FAILED.errorKey,
        });

        return acc;
      }

      const resultsByMode = tokenState.matchJSONValueByType<PartialUrlAssets>(
        {
          bitmap: v => [{ url: v.url, format: v.format, provider: v.provider }],
          vector: v => [{ url: v.url, format: v.format, provider: v.provider }],
          bitmaps: v => v.files,
          vectors: v => v.files,
          font: v => unwrapFilesValue(v.files),
          textStyle: v => unwrapFilesValue(v.font.files),
        },
        _ => undefined,
      );

      if (!resultsByMode) return acc;

      for (const [mode, results] of Object.entries(resultsByMode)) {
        for (const result of results) {
          acc.push({
            path: tokenState.path.toArray(),
            mode,
            format: result.format,
            provider: result.provider,
            url: result.url,
            // @ts-expect-error - Needs to narrow down the type
            token: tokenState.getJSONToken(),
          });
        }
      }

      return acc;
    },
    [] as AssetDataBox['assets'],
  );
}