// Copyright (C) 2004-2025 Artifex Software, Inc.

//

// This file is part of MuPDF.

//

// MuPDF is free software: you can redistribute it and/or modify it under the

// terms of the GNU Affero General Public License as published by the Free

// Software Foundation, either version 3 of the License, or (at your option)

// any later version.

//

// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more

// details.

//

// You should have received a copy of the GNU Affero General Public License

// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>

//

// Alternative licensing terms are available from the licensor.

// For commercial licensing, see <https://www.artifex.com/> or contact

// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,

// CA 94129, USA, for further information.

#include "mupdf/fitz.h"

#include "html-imp.h"

#include <string.h>

static fz_font *

fz_load_html_default_font(fz_context *ctx, fz_html_font_set *set, const char *family, int is_bold, int is_italic)

{

  int is_mono = !strcmp(family, "monospace");

  int is_sans = !strcmp(family, "sans-serif");

  const char *real_family = is_mono ? "Courier" : is_sans ? "Helvetica" : "Charis SIL";

  const char *backup_family = is_mono ? "Courier" : is_sans ? "Helvetica" : "Times";

  int idx = (is_mono ? 8 : is_sans ? 4 : 0) + is_bold * 2 + is_italic;

  if (!set->fonts[idx])

  {

    const unsigned char *data;

    int size;

    data = fz_lookup_builtin_font(ctx, real_family, is_bold, is_italic, &size);

    if (!data)

      data = fz_lookup_builtin_font(ctx, backup_family, is_bold, is_italic, &size);

    if (!data)

      fz_throw(ctx, FZ_ERROR_UNSUPPORTED, "cannot load html font: %s", real_family);

    set->fonts[idx] = fz_new_font_from_memory(ctx, NULL, data, size, 0, 1);

    fz_font_flags(set->fonts[idx])->is_serif = !is_sans;

  }

  return set->fonts[idx];

}

void

fz_add_html_font_face(fz_context *ctx, fz_html_font_set *set,

  const char *family, int is_bold, int is_italic, int is_small_caps,

  const char *src, fz_font *font)

{

  fz_html_font_face *custom = fz_malloc_struct(ctx, fz_html_font_face);

  fz_font_flags_t *flags;

  flags = fz_font_flags(font);

  if (is_bold && !flags->is_bold)

    flags->fake_bold = 1;

  if (is_italic && !flags->is_italic)

    flags->fake_italic = 1;

  fz_try(ctx)

  {

    custom->font = fz_keep_font(ctx, font);

    custom->src = fz_strdup(ctx, src);

    custom->family = fz_strdup(ctx, family);

    custom->is_bold = is_bold;

    custom->is_italic = is_italic;

    custom->is_small_caps = is_small_caps;

    custom->next = set->custom;

    set->custom = custom;

  }

  fz_catch(ctx)

  {

    fz_drop_font(ctx, custom->font);

    fz_free(ctx, custom->src);

    fz_free(ctx, custom->family);

    fz_rethrow(ctx);

  }

}

fz_font *

fz_load_html_font(fz_context *ctx, fz_html_font_set *set,

  const char *family, int is_bold, int is_italic, int is_small_caps)

{

  fz_html_font_face *custom;

  const unsigned char *data;

  int best_score = 0;

  fz_font *best_font = NULL;

  fz_font *font;

  int size;

  for (custom = set->custom; custom; custom = custom->next)

  {

    if (!strcmp(family, custom->family))

    {

      int score =

        1 * (is_bold == custom->is_bold) +

        2 * (is_italic == custom->is_italic) +

        4 * (is_small_caps == custom->is_small_caps);

      if (score > best_score)

      {

        best_score = score;

        best_font = custom->font;

      }

    }

  }

  // We found a perfect match!

  if (best_font && best_score == 1 + 2 + 4)

    return best_font;

  // FIXME: Font matching logic is not right here. Should we check for

  // user (system) fonts before we check for builtin ones to allow for

  // users to override inbuilt ones? If we fail to find an exact stylistic

  // match, we currently accept an inexact one before we look for an

  // exact (or better) user (system) font.

  // Try to load a perfect match.

  data = fz_lookup_builtin_font(ctx, family, is_bold, is_italic, &size);

  if (!data)

    data = fz_lookup_builtin_font(ctx, family, 0, 0, &size);

  if (data)

  {

    font = fz_new_font_from_memory(ctx, NULL, data, size, 0, 0);

    fz_try(ctx)

      fz_add_html_font_face(ctx, set, family, is_bold, is_italic, 0, "<builtin>", font);

    fz_always(ctx)

      fz_drop_font(ctx, font);

    fz_catch(ctx)

      fz_rethrow(ctx);

    return font;

  }

  else

  {

    font = fz_load_system_font(ctx, family, is_bold, is_italic, 0);

    if (font)

    {

      fz_try(ctx)

        fz_add_html_font_face(ctx, set, family, is_bold, is_italic, 0, "<system>", font);

      fz_always(ctx)

        fz_drop_font(ctx, font);

      fz_catch(ctx)

        fz_rethrow(ctx);

      return font;

    }

  }

  // Use the imperfect match from before.

  if (best_font)

    return best_font;

  // Handle the "default" font aliases.

  if (!strcmp(family, "monospace") || !strcmp(family, "sans-serif") || !strcmp(family, "serif"))

    return fz_load_html_default_font(ctx, set, family, is_bold, is_italic);

  return NULL;

}

fz_html_font_set *fz_new_html_font_set(fz_context *ctx)

{

  return fz_malloc_struct(ctx, fz_html_font_set);

}

void fz_drop_html_font_set(fz_context *ctx, fz_html_font_set *set)

{

  fz_html_font_face *font, *next;

  int i;

  if (!set)

    return;

  font = set->custom;

  while (font)

  {

    next = font->next;

    fz_drop_font(ctx, font->font);

    fz_free(ctx, font->src);

    fz_free(ctx, font->family);

    fz_free(ctx, font);

    font = next;

  }

  for (i = 0; i < (int)nelem(set->fonts); ++i)

    fz_drop_font(ctx, set->fonts[i]);

  fz_free(ctx, set);

}