/*

 * Copyright © 2012,2013  Mozilla Foundation.

 * Copyright © 2012,2013  Google, Inc.

 *

 *  This is part of HarfBuzz, a text shaping library.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and its documentation for any purpose, provided that the

 * above copyright notice and the following two paragraphs appear in

 * all copies of this software.

 *

 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR

 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES

 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN

 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH

 * DAMAGE.

 *

 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,

 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS

 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO

 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 *

 * Mozilla Author(s): Jonathan Kew

 * Google Author(s): Behdad Esfahbod

 */

#include "hb-coretext.h"

#include <math.h>

/* https://developer.apple.com/documentation/coretext/1508745-ctfontcreatewithgraphicsfont */

#define HB_CORETEXT_DEFAULT_FONT_SIZE 12.f

static CGFloat

coretext_font_size_from_ptem (float ptem)

{

  /* CoreText points are CSS pixels (96 per inch),

   * NOT typographic points (72 per inch).

   *

   * https://developer.apple.com/library/content/documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/Explained/Explained.html

   */

  ptem *= 96.f / 72.f;

  return ptem <= 0.f ? HB_CORETEXT_DEFAULT_FONT_SIZE : ptem;

}

static float

coretext_font_size_to_ptem (CGFloat size)

{

  size *= 72.f / 96.f;

  return size <= 0.f ? 0 : size;

}

static void

release_table_data (void *user_data)

{

  CFDataRef cf_data = reinterpret_cast<CFDataRef> (user_data);

  CFRelease(cf_data);

}

static hb_blob_t *

reference_table  (hb_face_t *face HB_UNUSED, hb_tag_t tag, void *user_data)

{

  CGFontRef cg_font = reinterpret_cast<CGFontRef> (user_data);

  CFDataRef cf_data = CGFontCopyTableForTag (cg_font, tag);

  if (unlikely (!cf_data))

    return nullptr;

  const char *data = reinterpret_cast<const char*> (CFDataGetBytePtr (cf_data));

  const size_t length = CFDataGetLength (cf_data);

  if (!data || !length)

  {

    CFRelease (cf_data);

    return nullptr;

  }

  return hb_blob_create (data, length, HB_MEMORY_MODE_READONLY,

                         reinterpret_cast<void *> (const_cast<__CFData *> (cf_data)),

                         release_table_data);

}

static void

_hb_cg_font_release (void *data)

{

  CGFontRelease ((CGFontRef) data);

}

static CTFontDescriptorRef

{

  // TODO Handle allocation failures?

  CTFontDescriptorRef last_resort = CTFontDescriptorCreateWithNameAndSize (CFSTR("LastResort"), 0);

  CFArrayRef cascade_list = CFArrayCreate (kCFAllocatorDefault,

                                           (const void **) &last_resort,

                                           1,

                                           &kCFTypeArrayCallBacks);

  CFRelease (last_resort);

  CFDictionaryRef attributes = CFDictionaryCreate (kCFAllocatorDefault,

                                                   (const void **) &kCTFontCascadeListAttribute,

                                                   (const void **) &cascade_list,

                                                   1,

                                                   &kCFTypeDictionaryKeyCallBacks,

                                                   &kCFTypeDictionaryValueCallBacks);

  CFRelease (cascade_list);

  CTFontDescriptorRef font_desc = CTFontDescriptorCreateWithAttributes (attributes);

  CFRelease (attributes);

  return font_desc;

}

static void

release_data (void *info, const void *data, size_t size)

{

  assert (hb_blob_get_length ((hb_blob_t *) info) == size &&

          hb_blob_get_data ((hb_blob_t *) info, nullptr) == data);

  hb_blob_destroy ((hb_blob_t *) info);

}

static CGFontRef

create_cg_font (hb_face_t *face)

{

  CGFontRef cg_font = nullptr;

  if (face->destroy == _hb_cg_font_release)

  {

    cg_font = CGFontRetain ((CGFontRef) face->user_data);

  }

  else

  {

    hb_blob_t *blob = hb_face_reference_blob (face);

    unsigned int blob_length;

    const char *blob_data = hb_blob_get_data (blob, &blob_length);

    if (unlikely (!blob_length))

      DEBUG_MSG (CORETEXT, face, "Face has empty blob");

    CGDataProviderRef provider = CGDataProviderCreateWithData (blob, blob_data, blob_length, &release_data);

    if (likely (provider))

    {

      cg_font = CGFontCreateWithDataProvider (provider);

      if (unlikely (!cg_font))

        DEBUG_MSG (CORETEXT, face, "Face CGFontCreateWithDataProvider() failed");

      CGDataProviderRelease (provider);

    }

  }

  return cg_font;

}

static CTFontRef

create_ct_font (CGFontRef cg_font, CGFloat font_size)

{

  CTFontRef ct_font = nullptr;

  /* CoreText does not enable trak table usage / tracking when creating a CTFont

   * using CTFontCreateWithGraphicsFont. The only way of enabling tracking seems

   * to be through the CTFontCreateUIFontForLanguage call. */

  CFStringRef cg_postscript_name = CGFontCopyPostScriptName (cg_font);

  if (CFStringHasPrefix (cg_postscript_name, CFSTR (".SFNSText")) ||

      CFStringHasPrefix (cg_postscript_name, CFSTR (".SFNSDisplay")))

  {

#if MAC_OS_X_VERSION_MIN_REQUIRED < 1080

# define kCTFontUIFontSystem kCTFontSystemFontType

# define kCTFontUIFontEmphasizedSystem kCTFontEmphasizedSystemFontType

#endif

    CTFontUIFontType font_type = kCTFontUIFontSystem;

    if (CFStringHasSuffix (cg_postscript_name, CFSTR ("-Bold")))

      font_type = kCTFontUIFontEmphasizedSystem;

    ct_font = CTFontCreateUIFontForLanguage (font_type, font_size, nullptr);

    CFStringRef ct_result_name = CTFontCopyPostScriptName(ct_font);

    if (CFStringCompare (ct_result_name, cg_postscript_name, 0) != kCFCompareEqualTo)

    {

      CFRelease(ct_font);

      ct_font = nullptr;

    }

    CFRelease (ct_result_name);

  }

  CFRelease (cg_postscript_name);

  if (!ct_font)

    ct_font = CTFontCreateWithGraphicsFont (cg_font, font_size, nullptr, nullptr);

  if (unlikely (!ct_font)) {

    DEBUG_MSG (CORETEXT, cg_font, "Font CTFontCreateWithGraphicsFont() failed");

    return nullptr;

  }

  /* crbug.com/576941 and crbug.com/625902 and the investigation in the latter

   * bug indicate that the cascade list reconfiguration occasionally causes

   * crashes in CoreText on OS X 10.9, thus let's skip this step on older

   * operating system versions. Except for the emoji font, where _not_

   * reconfiguring the cascade list causes CoreText crashes. For details, see

   * crbug.com/549610 */

  // 0x00070000 stands for "kCTVersionNumber10_10", see CoreText.h

  if (&CTGetCoreTextVersion != nullptr && CTGetCoreTextVersion() < 0x00070000) {

    CFStringRef fontName = CTFontCopyPostScriptName (ct_font);

    bool isEmojiFont = CFStringCompare (fontName, CFSTR("AppleColorEmoji"), 0) == kCFCompareEqualTo;

    CFRelease (fontName);

    if (!isEmojiFont)

      return ct_font;

  }

  CFURLRef original_url = nullptr;

  ATSFontRef atsFont;

  FSRef fsref;

  OSStatus status;

  atsFont = CTFontGetPlatformFont (ct_font, NULL);

  status = ATSFontGetFileReference (atsFont, &fsref);

  if (status == noErr)

    original_url = CFURLCreateFromFSRef (NULL, &fsref);

#else

  original_url = (CFURLRef) CTFontCopyAttribute (ct_font, kCTFontURLAttribute);

#endif

  /* Create font copy with cascade list that has LastResort first; this speeds up CoreText

   * font fallback which we don't need anyway. */

  {

    CTFontDescriptorRef last_resort_font_desc = get_last_resort_font_desc ();

    CTFontRef new_ct_font = CTFontCreateCopyWithAttributes (ct_font, 0.0, nullptr, last_resort_font_desc);

    CFRelease (last_resort_font_desc);

    if (new_ct_font)

    {

      /* The CTFontCreateCopyWithAttributes call fails to stay on the same font

       * when reconfiguring the cascade list and may switch to a different font

       * when there are fonts that go by the same name, since the descriptor is

       * just name and size.

       *

       * Avoid reconfiguring the cascade lists if the new font is outside the

       * system locations that we cannot access from the sandboxed renderer

       * process in Blink. This can be detected by the new file URL location

       * that the newly found font points to. */

      CFURLRef new_url = nullptr;

      atsFont = CTFontGetPlatformFont (new_ct_font, NULL);

      status = ATSFontGetFileReference (atsFont, &fsref);

      if (status == noErr)

        new_url = CFURLCreateFromFSRef (NULL, &fsref);

#else

      new_url = (CFURLRef) CTFontCopyAttribute (new_ct_font, kCTFontURLAttribute);

#endif

      // Keep reconfigured font if URL cannot be retrieved (seems to be the case

      // on Mac OS 10.12 Sierra), speculative fix for crbug.com/625606

      if (!original_url || !new_url || CFEqual (original_url, new_url)) {

        CFRelease (ct_font);

        ct_font = new_ct_font;

      } else {

        CFRelease (new_ct_font);

        DEBUG_MSG (CORETEXT, ct_font, "Discarding reconfigured CTFont, location changed.");

      }

      if (new_url)

        CFRelease (new_url);

    }

    else

      DEBUG_MSG (CORETEXT, ct_font, "Font copy with empty cascade list failed");

  }

  if (original_url)

    CFRelease (original_url);

  return ct_font;

}

_hb_coretext_shaper_face_data_create (hb_face_t *face)

{

  CGFontRef cg_font = create_cg_font (face);

  if (unlikely (!cg_font))

  {

    DEBUG_MSG (CORETEXT, face, "CGFont creation failed..");

    return nullptr;

  }

}

void

{

  CFRelease ((CGFontRef) data);

}

hb_face_t *

hb_coretext_face_create (CGFontRef cg_font)

{

  return hb_face_create_for_tables (reference_table, CGFontRetain (cg_font), _hb_cg_font_release);

}

/*

 * Since: 0.9.10

 */

CGFontRef

hb_coretext_face_get_cg_font (hb_face_t *face)

{

}

_hb_coretext_shaper_font_data_create (hb_font_t *font)

{

  hb_face_t *face = font->face;

  CTFontRef ct_font = create_ct_font (cg_font, coretext_font_size_from_ptem (font->ptem));

  if (unlikely (!ct_font))

  {

    DEBUG_MSG (CORETEXT, font, "CGFont creation failed..");

    return nullptr;

  }

}

void

{

  CFRelease ((CTFontRef) data);

}

/*

 * Since: 1.7.2

 */

hb_font_t *

hb_coretext_font_create (CTFontRef ct_font)

{

  CGFontRef cg_font = CTFontCopyGraphicsFont (ct_font, nullptr);

  hb_face_t *face = hb_coretext_face_create (cg_font);

  CFRelease (cg_font);

  hb_font_t *font = hb_font_create (face);

  hb_face_destroy (face);

    return font;

  hb_font_set_ptem (font, coretext_font_size_to_ptem (CTFontGetSize(ct_font)));

  /* Let there be dragons here... */

  return font;

}

CTFontRef

hb_coretext_font_get_ct_font (hb_font_t *font)

{

}

/*

 * shaper

 */

struct feature_record_t {

  unsigned int feature;

  unsigned int setting;

};

struct active_feature_t {

  feature_record_t rec;

  unsigned int order;

  static int cmp (const void *pa, const void *pb) {

    const active_feature_t *a = (const active_feature_t *) pa;

    const active_feature_t *b = (const active_feature_t *) pb;

    return a->rec.feature < b->rec.feature ? -1 : a->rec.feature > b->rec.feature ? 1 :

           a->order < b->order ? -1 : a->order > b->order ? 1 :

           a->rec.setting < b->rec.setting ? -1 : a->rec.setting > b->rec.setting ? 1 :

           0;

  }

  bool operator== (const active_feature_t *f) {

    return cmp (this, f) == 0;

  }

};

struct feature_event_t {

  unsigned int index;

  bool start;

  active_feature_t feature;

  static int cmp (const void *pa, const void *pb) {

    const feature_event_t *a = (const feature_event_t *) pa;

    const feature_event_t *b = (const feature_event_t *) pb;

    return a->index < b->index ? -1 : a->index > b->index ? 1 :

           a->start < b->start ? -1 : a->start > b->start ? 1 :

           active_feature_t::cmp (&a->feature, &b->feature);

  }

};

struct range_record_t {

  CTFontRef font;

  unsigned int index_first; /* == start */

  unsigned int index_last;  /* == end - 1 */

};

hb_bool_t

_hb_coretext_shape (hb_shape_plan_t    *shape_plan,

                    hb_font_t          *font,

                    hb_buffer_t        *buffer,

                    const hb_feature_t *features,

                    unsigned int        num_features)

{

  hb_face_t *face = font->face;

  CGFloat ct_font_size = CTFontGetSize (ct_font);

  CGFloat x_mult = (CGFloat) font->x_scale / ct_font_size;

  CGFloat y_mult = (CGFloat) font->y_scale / ct_font_size;

  /* Attach marks to their bases, to match the 'ot' shaper.

   * Note that this only makes us be closer to the 'ot' shaper,

   * but by no means the same.  For example, if there's

   * B1 M1 B2 M2, and B1-B2 form a ligature, M2's cluster will

   * continue pointing to B2 even though B2 was merged into B1's

   * cluster... */

  if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)

  {

    hb_unicode_funcs_t *unicode = buffer->unicode;

    unsigned int count = buffer->len;

    hb_glyph_info_t *info = buffer->info;

    for (unsigned int i = 1; i < count; i++)

      if (HB_UNICODE_GENERAL_CATEGORY_IS_MARK (unicode->general_category (info[i].codepoint)))

        buffer->merge_clusters (i - 1, i + 1);

  }

  /*

   * Set up features.

   * (copied + modified from code from hb-uniscribe.cc)

   */

  if (num_features)

  {

    /* Sort features by start/end events. */

    for (unsigned int i = 0; i < num_features; i++)

    {

      if (!mapping)

        continue;

      active_feature_t feature;

      feature.rec.feature = mapping->aatFeatureType;

      feature.rec.setting = features[i].value ? mapping->selectorToEnable : mapping->selectorToDisable;

      feature.order = i;

      feature_event_t *event;