/* Font support for Haiku windowing

Copyright (C) 2021 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.

GNU Emacs 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */

#include <config.h>

#include "lisp.h"
#include "dispextern.h"
#include "composite.h"
#include "blockinput.h"
#include "charset.h"
#include "frame.h"
#include "window.h"
#include "fontset.h"
#include "haikuterm.h"
#include "character.h"
#include "font.h"
#include "termchar.h"
#include "pdumper.h"
#include "haiku_support.h"

#include <math.h>
#include <stdlib.h>

static Lisp_Object
haikufont_get_fallback_entity (void)
{
  Lisp_Object ent = font_make_entity ();
  ASET (ent, FONT_TYPE_INDEX, Qhaiku);
  ASET (ent, FONT_FOUNDRY_INDEX, Qhaiku);
  ASET (ent, FONT_FAMILY_INDEX, Qnil);
  ASET (ent, FONT_ADSTYLE_INDEX, Qnil);
  ASET (ent, FONT_REGISTRY_INDEX, Qiso8859_1);
  ASET (ent, FONT_SIZE_INDEX, make_fixnum (0));
  ASET (ent, FONT_AVGWIDTH_INDEX, make_fixnum (0));
  ASET (ent, FONT_SPACING_INDEX, make_fixnum (FONT_SPACING_MONO));
  FONT_SET_STYLE (ent, FONT_WIDTH_INDEX, Qnil);
  FONT_SET_STYLE (ent, FONT_WEIGHT_INDEX, Qnil);
  FONT_SET_STYLE (ent, FONT_SLANT_INDEX, Qnil);

  return ent;
}

static Lisp_Object
haikufont_get_cache (struct frame *frame)
{
  return FRAME_DISPLAY_INFO (frame)->name_list_element;
}

static Lisp_Object
haikufont_weight_to_lisp (int weight)
{
  switch (weight)
    {
    case HAIKU_THIN:
      return Qthin;
    case HAIKU_ULTRALIGHT:
      return Qultra_light;
    case HAIKU_EXTRALIGHT:
      return Qextra_light;
    case HAIKU_LIGHT:
      return Qlight;
    case HAIKU_SEMI_LIGHT:
      return Qsemi_light;
    case HAIKU_REGULAR:
      return Qnormal;
    case HAIKU_SEMI_BOLD:
      return Qsemi_bold;
    case HAIKU_BOLD:
      return Qbold;
    case HAIKU_EXTRA_BOLD:
      return Qextra_bold;
    case HAIKU_ULTRA_BOLD:
      return Qultra_bold;
    }
  emacs_abort ();
}

static int
haikufont_lisp_to_weight (Lisp_Object weight)
{
  if (EQ (weight, Qthin))
    return HAIKU_THIN;
  if (EQ (weight, Qultra_light))
    return HAIKU_ULTRALIGHT;
  if (EQ (weight, Qextra_light))
    return HAIKU_EXTRALIGHT;
  if (EQ (weight, Qlight))
    return HAIKU_LIGHT;
  if (EQ (weight, Qsemi_light))
    return HAIKU_SEMI_LIGHT;
  if (EQ (weight, Qnormal))
    return HAIKU_REGULAR;
  if (EQ (weight, Qsemi_bold))
    return HAIKU_SEMI_BOLD;
  if (EQ (weight, Qbold))
    return HAIKU_BOLD;
  if (EQ (weight, Qextra_bold))
    return HAIKU_EXTRA_BOLD;
  if (EQ (weight, Qultra_bold))
    return HAIKU_ULTRA_BOLD;

  emacs_abort ();
}

static Lisp_Object
haikufont_slant_to_lisp (enum haiku_font_slant slant)
{
  switch (slant)
    {
    case SLANT_ITALIC:
      return Qitalic;
    case SLANT_REGULAR:
      return Qnormal;
    case SLANT_OBLIQUE:
      return Qoblique;
    }
  emacs_abort ();
}

static enum haiku_font_slant
haikufont_lisp_to_slant (Lisp_Object slant)
{
  if (EQ (slant, Qitalic) ||
      EQ (slant, Qreverse_italic))
    return SLANT_ITALIC;
  if (EQ (slant, Qoblique) ||
      EQ (slant, Qreverse_oblique))
    return SLANT_OBLIQUE;
  if (EQ (slant, Qnormal))
    return SLANT_REGULAR;
  emacs_abort ();
}

static int
haikufont_maybe_handle_special_family (Lisp_Object family,
				       struct haiku_font_pattern *ptn)
{
  CHECK_SYMBOL (family);

  if (EQ (family, Qmonospace) || EQ (family, Qfixed))
    {
      BFont_populate_fixed_family (ptn);
      return 1;
    }
  else if (EQ (family, intern ("Sans Serif")))
    {
      BFont_populate_plain_family (ptn);
      return 1;
    }
  return 0;
}

static Lisp_Object
haikufont_pattern_to_entity (struct haiku_font_pattern *ptn)
{
  Lisp_Object ent = font_make_entity ();
  ASET (ent, FONT_TYPE_INDEX, Qhaiku);
  ASET (ent, FONT_FOUNDRY_INDEX, Qhaiku);
  ASET (ent, FONT_FAMILY_INDEX, Qdefault);
  ASET (ent, FONT_ADSTYLE_INDEX, Qnil);
  ASET (ent, FONT_REGISTRY_INDEX, Qiso8859_1);
  ASET (ent, FONT_SIZE_INDEX, make_fixnum (0));
  ASET (ent, FONT_AVGWIDTH_INDEX, make_fixnum (0));
  ASET (ent, FONT_SPACING_INDEX, make_fixnum (FONT_SPACING_MONO));
  FONT_SET_STYLE (ent, FONT_WIDTH_INDEX, Qnormal);
  FONT_SET_STYLE (ent, FONT_WEIGHT_INDEX, Qnormal);
  FONT_SET_STYLE (ent, FONT_SLANT_INDEX, Qnormal);

  if (ptn->specified & FSPEC_FAMILY)
    ASET (ent, FONT_FAMILY_INDEX, intern (ptn->family));
  else
    ASET (ent, FONT_FAMILY_INDEX, Qdefault);

  if (ptn->specified & FSPEC_STYLE)
    ASET (ent, FONT_ADSTYLE_INDEX, intern (ptn->style));
  else
    {
      if (ptn->specified & FSPEC_WEIGHT)
	FONT_SET_STYLE (ent, FONT_WEIGHT_INDEX,
			haikufont_weight_to_lisp (ptn->weight));
      if (ptn->specified & FSPEC_SLANT)
	FONT_SET_STYLE (ent, FONT_SLANT_INDEX,
			haikufont_slant_to_lisp (ptn->slant));
    }

  if (ptn->specified & FSPEC_SPACING)
    ASET (ent, FONT_SPACING_INDEX,
	  make_fixnum (ptn->mono_spacing_p ?
		       FONT_SPACING_MONO : FONT_SPACING_PROPORTIONAL));
  return ent;
}

static void
haikufont_spec_or_entity_to_pattern (Lisp_Object ent,
				     int list_p,
				     struct haiku_font_pattern *ptn)
{
  Lisp_Object tem;
  ptn->specified = 0;

  tem = AREF (ent, FONT_ADSTYLE_INDEX);
  if (!NILP (tem))
    {
      ptn->specified |= FSPEC_STYLE;
      strncpy ((char *) &ptn->style,
	       SSDATA (SYMBOL_NAME (tem)),
	       sizeof ptn->style - 1);
    }

  tem = FONT_SLANT_SYMBOLIC (ent);
  if (!NILP (tem))
    {
       ptn->specified |= FSPEC_SLANT;
       ptn->slant = haikufont_lisp_to_slant (tem);
    }

  tem = FONT_WEIGHT_SYMBOLIC (ent);
  if (!NILP (tem))
    {
      ptn->specified |= FSPEC_WEIGHT;
      ptn->weight = haikufont_lisp_to_weight (tem);
    }

  tem = AREF (ent, FONT_SPACING_INDEX);
  if (FIXNUMP (tem))
    {
      ptn->specified |= FSPEC_SPACING;
      ptn->mono_spacing_p = XFIXNUM (tem) != FONT_SPACING_PROPORTIONAL;
    }

  tem = AREF (ent, FONT_FAMILY_INDEX);
  if (!NILP (tem) && (!list_p ||
		      !haikufont_maybe_handle_special_family (tem, ptn)))
    {
      ptn->specified |= FSPEC_FAMILY;
      strncpy ((char *) &ptn->family,
	       SSDATA (SYMBOL_NAME (tem)),
	       sizeof ptn->family - 1);
    }
}

static Lisp_Object
haikufont_match (struct frame *f, Lisp_Object font_spec)
{
  block_input ();
  Lisp_Object tem = Qnil;
  struct haiku_font_pattern ptn;
  haikufont_spec_or_entity_to_pattern (font_spec, 1, &ptn);
  ptn.specified &= ~FSPEC_FAMILY;
  struct haiku_font_pattern *found = BFont_find (&ptn);
  if (found)
    {
      tem = haikufont_pattern_to_entity (found);
      haiku_font_pattern_free (found);
    }
  unblock_input ();
  return !NILP (tem) ? tem : haikufont_get_fallback_entity ();
}

static Lisp_Object
haikufont_list (struct frame *f, Lisp_Object font_spec)
{
  block_input ();
  Lisp_Object lst = Qnil;
  struct haiku_font_pattern ptn;
  haikufont_spec_or_entity_to_pattern (font_spec, 1, &ptn);
  struct haiku_font_pattern *found = BFont_find (&ptn);
  if (found)
    {
      for (struct haiku_font_pattern *pt = found;
	   pt; pt = pt->next)
	lst = Fcons (haikufont_pattern_to_entity (pt), lst);
      haiku_font_pattern_free (found);
    }
  unblock_input ();
  return lst;
}

static unsigned int
haikufont_encode_char (struct font *font, int c)
{
  struct haikufont_info *info = (struct haikufont_info *) font;

  if (c < HAVE_CHAR_CACHE_MAX && info->have_char_cache[c])
    return info->have_char_cache[c] < 0 ? FONT_INVALID_CODE : c;

  if (!BFont_have_char_p (((struct haikufont_info *) font)->be_font, c))
    {
      if (c < HAVE_CHAR_CACHE_MAX)
	info->have_char_cache[c] = -1;
      return FONT_INVALID_CODE;
    }
  if (c < HAVE_CHAR_CACHE_MAX)
    info->have_char_cache[c] = 1;

  return c;
}

static int
haikufont_have_char (Lisp_Object font, int c)
{
  if (FONT_ENTITY_P (font))
    return -1;

  return haikufont_encode_char (XFONT_OBJECT (font), c)
    != FONT_INVALID_CODE;
}

static Lisp_Object
haikufont_open (struct frame *f, Lisp_Object font_entity, int x)
{
  struct haikufont_info *font_info;
  struct haiku_font_pattern ptn;
  struct font *font;
  void *be_font;
  Lisp_Object font_object;
  Lisp_Object tem;

  block_input ();
  if (x <= 0)
    {
      /* Get pixel size from frame instead */
      tem = get_frame_param (f, Qfontsize);
      x = NILP (tem) ? 0 : XFIXNAT (tem);
    }

  haikufont_spec_or_entity_to_pattern (font_entity, 0, &ptn);

  if (BFont_open_pattern (&ptn, &be_font, x))
    {
      unblock_input ();
      return Qnil;
    }

  font_object = font_make_object (VECSIZE (struct haikufont_info),
				  font_entity, x);

  ASET (font_object, FONT_TYPE_INDEX, Qhaiku);
  font_info = (struct haikufont_info *) XFONT_OBJECT (font_object);
  font = (struct font *) font_info;

  memset (font_info->have_char_cache, 0,
	  HAVE_CHAR_CACHE_MAX * sizeof (int));
  memset (font_info->met_cache, 0,
	  HAVE_CHAR_CACHE_MAX * sizeof (struct font_metrics));

  if (!font)
    {
      unblock_input ();
      return Qnil;
    }

  font_info->be_font = be_font;
  font->pixel_size = 0;
  font->driver = &haikufont_driver;
  font->encoding_charset = -1;
  font->repertory_charset = -1;
  font->default_ascent = 0;
  font->vertical_centering = 0;
  font->baseline_offset = 0;
  font->relative_compose = 0;

  font->props[FONT_FULLNAME_INDEX] =
    build_unibyte_string ("fixed");

  int px_size, min_width, max_width,
    avg_width, height, space_width, ascent,
    descent, underline_pos, underline_thickness;

  BFont_dat (be_font, &px_size, &min_width,
	     &max_width, &avg_width, &height,
	     &space_width, &ascent, &descent,
	     &underline_pos, &underline_thickness);

  font->pixel_size = px_size;
  font->min_width = min_width;
  font->max_width = max_width;
  font->average_width = avg_width;
  font->height = height;
  font->space_width = space_width;
  font->ascent = ascent;
  font->descent = descent;
  font->default_ascent = ascent;
  font->underline_position = underline_pos;
  font->underline_thickness = underline_thickness;

  font->vertical_centering = 0;
  font->baseline_offset = 0;
  font->relative_compose = 0;

  font->props[FONT_NAME_INDEX] = Ffont_xlfd_name (font_object, Qnil);

  unblock_input ();
  return font_object;
}

static void
haikufont_close (struct font *font)
{
  struct haikufont_info *info = (struct haikufont_info *) font;

  block_input ();
  if (info && info->be_font)
    BFont_close (info->be_font);
  unblock_input ();
}

static void
haikufont_prepare_face (struct frame *f, struct face *face)
{

}

static void
haikufont_glyph_extents (struct font *font, unsigned code,
			 struct font_metrics *metrics)
{
  struct haikufont_info *info = (struct haikufont_info *) font;

  if (code < HAVE_CHAR_CACHE_MAX &&
      info->met_cache[code].ascent != 0)
    {
      *metrics = info->met_cache[code];
      return;
    }

  unsigned char utf8[MAX_MULTIBYTE_LENGTH];
  memset (utf8, 0, MAX_MULTIBYTE_LENGTH);
  CHAR_STRING (code, utf8);
  int advance, lb, rb;
  BFont_char_bounds (info->be_font, (const char *) utf8, &advance, &lb, &rb);

  metrics->lbearing = lb;
  metrics->rbearing = rb;
  metrics->width = advance;
  metrics->ascent = font->ascent;
  metrics->descent = font->descent;

  if (code < HAVE_CHAR_CACHE_MAX)
    info->met_cache[code] = *metrics;
}

static void
haikufont_text_extents (struct font *font, const unsigned int *code,
			int nglyphs, struct font_metrics *metrics)
{
  int totalwidth = 0;
  memset (metrics, 0, sizeof (struct font_metrics));

  block_input ();
  for (int i = 0; i < nglyphs; i++)
    {
      struct font_metrics m;
      haikufont_glyph_extents (font, code[i], &m);
      if (metrics)
	{
	  if (totalwidth + m.lbearing < metrics->lbearing)
	    metrics->lbearing = totalwidth + m.lbearing;
	  if (totalwidth + m.rbearing > metrics->rbearing)
	    metrics->rbearing = totalwidth + m.rbearing;
	  if (m.ascent > metrics->ascent)
	    metrics->ascent = m.ascent;
	  if (m.descent > metrics->descent)
	    metrics->descent = m.descent;
	}
      totalwidth += m.width;
    }

  unblock_input ();

  if (metrics)
    metrics->width = totalwidth;
}

static int
haikufont_draw (struct glyph_string *s, int from, int to,
		int x, int y, bool with_background)
{
  struct frame *f = s->f;
  struct face *face = s->face;
  struct font_info *info = (struct font_info *) s->font;
  unsigned char mb[MAX_MULTIBYTE_LENGTH];
  void *view = FRAME_HAIKU_VIEW (f);

  if (s->hl == DRAW_MOUSE_FACE)
    face = FACE_FROM_ID_OR_NULL (s->f,
				 MOUSE_HL_INFO (s->f)->mouse_face_face_id);
  if (!face)
    face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);

  block_input ();
  prepare_face_for_display (s->f, face);

  BView_draw_lock (view);
  BView_StartClip (view);
  if (with_background)
    {
      int fibw = FRAME_INTERNAL_BORDER_WIDTH (s->f);
      int vx, vy, width, height;
      vx = s->x;
      vy = s->y;
      width = s->width;
      height = FONT_HEIGHT (face->font);
      if (s->face->box != FACE_NO_BOX && s->first_glyph->left_box_line_p)
	vx += max (s->face->box_vertical_line_width, 0);


      int mbox_line_width = max (s->face->box_vertical_line_width, 0);

      if (s->row->full_width_p)
        {
          if (vx <= fibw + 1 + mbox_line_width)
            {
              width += vx - mbox_line_width;
              vx = mbox_line_width;
            }
          if (FRAME_PIXEL_WIDTH (s->f) - (vx + width)
                <= fibw+1)
            width += fibw;
        }
      if (s->face->box == FACE_NO_BOX)
        {
          /* Expand unboxed top row over internal border.  */
          if (vy <= fibw + 1 + mbox_line_width)
            {
              height += vy;
              vy = 0;
            }
        }
      else
        {
          int correction = abs (s->face->box_horizontal_line_width) + 1;
          vy += correction;
          height -= 2 * correction;
          correction = abs (s->face->box_vertical_line_width) + 1;
          vx += correction;
          width -= 2 * correction;
        }
      BView_SetHighColor (view, s->hl == DRAW_CURSOR ?
			  FRAME_CURSOR_COLOR (s->f).pixel : face->background);

      BView_FillRectangle (view, vx, vy, width, height);
      s->background_filled_p = 1;
    }

  if (s->hl == DRAW_CURSOR)
    BView_SetHighColor (view, FRAME_OUTPUT_DATA (s->f)->cursor_fg);
  else
    BView_SetHighColor (view, face->foreground);

  BView_MovePenTo (view, x, y);
  BView_SetFont (view, ((struct haikufont_info *) info)->be_font);

  if ((from == to) && s->char2b[from] <= 127)
    BView_DrawChar (view, (char) s->char2b[from]);
  else if (from == to)
    {
      int len = CHAR_STRING (s->char2b[from], mb);
      BView_DrawString (view, (char *) mb, len);
    }
  else
    {
      ptrdiff_t b_len = 0;
      char *b = xmalloc (b_len);

      for (int idx = from; idx < to; ++idx)
	{
	  int len = CHAR_STRING (s->char2b[idx], mb);
	  b = xrealloc (b, b_len = (b_len + len));
	  if (len == 1)
	    b[b_len - len] = mb[0];
	  else
	    memcpy (b + b_len - len, mb, len);
	}

      BView_DrawString (view, b, b_len);
      xfree (b);
    }
  BView_EndClip (view);
  BView_draw_unlock (view);
  unblock_input ();
  return 1;
}

struct font_driver const haikufont_driver =
  {
    .type = LISPSYM_INITIALLY (Qhaiku),
    .case_sensitive = true,
    .get_cache = haikufont_get_cache,
    .has_char = haikufont_have_char,
    .list = haikufont_list,
    .match = haikufont_match,
    .draw = haikufont_draw,
    .open_font = haikufont_open,
    .close_font = haikufont_close,
    .prepare_face = haikufont_prepare_face,
    .encode_char = haikufont_encode_char,
    .text_extents = haikufont_text_extents
  };

void
syms_of_haikufont (void)
{
  DEFSYM (Qfontsize, "fontsize");
  DEFSYM (Qfixed, "fixed");
  DEFSYM (Qplain, "plain");
  DEFSYM (Qultra_light, "ultra-light");
  DEFSYM (Qthin, "thin");
  DEFSYM (Qreverse_italic, "reverse-italic");
  DEFSYM (Qreverse_oblique, "reverse-oblique");
  DEFSYM (Qmonospace, "monospace");
}