/*

 * 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

 */

#define HB_SHAPER coretext

#include "hb-private.hh"

#include "hb-debug.hh"

#include "hb-shaper-impl-private.hh"

#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);

}

HB_SHAPER_DATA_ENSURE_DEFINE(coretext, face)

HB_SHAPER_DATA_ENSURE_DEFINE_WITH_CONDITION(coretext, font,

        fabs (CTFontGetSize((CTFontRef) data) - coretext_font_size_from_ptem (font->ptem)) <= .5

)

static CTFontDescriptorRef

get_last_resort_font_desc (void)

{

  // 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")))

  {

    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;

  }

  /* 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. */

      // 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_t *

_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;

  }

  return (hb_coretext_shaper_face_data_t *) cg_font;

}

void

_hb_coretext_shaper_face_data_destroy (hb_coretext_shaper_face_data_t *data)

{

  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)

{

  if (unlikely (!hb_coretext_shaper_face_data_ensure (face))) return nullptr;

  return (CGFontRef) HB_SHAPER_DATA_GET (face);

}

hb_coretext_shaper_font_data_t *

_hb_coretext_shaper_font_data_create (hb_font_t *font)

{

  hb_face_t *face = font->face;

  if (unlikely (!hb_coretext_shaper_face_data_ensure (face))) return nullptr;

  CGFontRef cg_font = (CGFontRef) HB_SHAPER_DATA_GET (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;

  }

  return (hb_coretext_shaper_font_data_t *) ct_font;

}

void

_hb_coretext_shaper_font_data_destroy (hb_coretext_shaper_font_data_t *data)

{

  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);

  if (unlikely (hb_object_is_inert (font)))

    return font;

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

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

  HB_SHAPER_DATA_GET (font) = (hb_coretext_shaper_font_data_t *) CFRetain (ct_font);

  return font;

}

CTFontRef

hb_coretext_font_get_ct_font (hb_font_t *font)

{

  if (unlikely (!hb_coretext_shaper_font_data_ensure (font))) return nullptr;

  return (CTFontRef) HB_SHAPER_DATA_GET (font);

}

/*

 * shaper shape_plan data

 */

struct hb_coretext_shaper_shape_plan_data_t {};

hb_coretext_shaper_shape_plan_data_t *

_hb_coretext_shaper_shape_plan_data_create (hb_shape_plan_t    *shape_plan HB_UNUSED,

                                             const hb_feature_t *user_features HB_UNUSED,

                                             unsigned int        num_user_features HB_UNUSED,

                                             const int          *coords HB_UNUSED,

                                             unsigned int        num_coords HB_UNUSED)

{

  return (hb_coretext_shaper_shape_plan_data_t *) HB_SHAPER_DATA_SUCCEEDED;

}

void

_hb_coretext_shaper_shape_plan_data_destroy (hb_coretext_shaper_shape_plan_data_t *data HB_UNUSED)

{

}

/*

 * 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 */

};

/* The following enum members are added in OS X 10.8. */

#define kAltHalfWidthTextSelector               6

#define kAltProportionalTextSelector            5

#define kAlternateHorizKanaOffSelector          1

#define kAlternateHorizKanaOnSelector           0

#define kAlternateKanaType                      34

#define kAlternateVertKanaOffSelector           3

#define kAlternateVertKanaOnSelector            2

#define kCaseSensitiveLayoutOffSelector         1

#define kCaseSensitiveLayoutOnSelector          0

#define kCaseSensitiveLayoutType                33

#define kCaseSensitiveSpacingOffSelector        3

#define kCaseSensitiveSpacingOnSelector         2

#define kContextualAlternatesOffSelector        1

#define kContextualAlternatesOnSelector         0

#define kContextualAlternatesType               36

#define kContextualLigaturesOffSelector         19

#define kContextualLigaturesOnSelector          18

#define kContextualSwashAlternatesOffSelector   5

#define kContextualSwashAlternatesOnSelector    4

#define kDefaultLowerCaseSelector               0

#define kDefaultUpperCaseSelector               0

#define kHistoricalLigaturesOffSelector         21

#define kHistoricalLigaturesOnSelector          20

#define kHojoCharactersSelector                 12

#define kJIS2004CharactersSelector              11

#define kLowerCasePetiteCapsSelector            2

#define kLowerCaseSmallCapsSelector             1

#define kLowerCaseType                          37

#define kMathematicalGreekOffSelector           11

#define kMathematicalGreekOnSelector            10

#define kNLCCharactersSelector                  13

#define kQuarterWidthTextSelector               4

#define kScientificInferiorsSelector            4

#define kStylisticAltEightOffSelector           17

#define kStylisticAltEightOnSelector            16

#define kStylisticAltEighteenOffSelector        37

#define kStylisticAltEighteenOnSelector         36

#define kStylisticAltElevenOffSelector          23

#define kStylisticAltElevenOnSelector           22

#define kStylisticAltFifteenOffSelector         31

#define kStylisticAltFifteenOnSelector          30

#define kStylisticAltFiveOffSelector            11

#define kStylisticAltFiveOnSelector             10

#define kStylisticAltFourOffSelector            9

#define kStylisticAltFourOnSelector             8

#define kStylisticAltFourteenOffSelector        29

#define kStylisticAltFourteenOnSelector         28

#define kStylisticAltNineOffSelector            19

#define kStylisticAltNineOnSelector             18

#define kStylisticAltNineteenOffSelector        39

#define kStylisticAltNineteenOnSelector         38

#define kStylisticAltOneOffSelector             3

#define kStylisticAltOneOnSelector              2

#define kStylisticAltSevenOffSelector           15

#define kStylisticAltSevenOnSelector            14

#define kStylisticAltSeventeenOffSelector       35

#define kStylisticAltSeventeenOnSelector        34

#define kStylisticAltSixOffSelector             13

#define kStylisticAltSixOnSelector              12

#define kStylisticAltSixteenOffSelector         33

#define kStylisticAltSixteenOnSelector          32

#define kStylisticAltTenOffSelector             21

#define kStylisticAltTenOnSelector              20

#define kStylisticAltThirteenOffSelector        27

#define kStylisticAltThirteenOnSelector         26

#define kStylisticAltThreeOffSelector           7

#define kStylisticAltThreeOnSelector            6

#define kStylisticAltTwelveOffSelector          25

#define kStylisticAltTwelveOnSelector           24

#define kStylisticAltTwentyOffSelector          41