/*

 * Copyright © 2018  Ebrahim Byagowi

 *

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

 */

#ifndef HB_OT_STAT_TABLE_HH

#define HB_OT_STAT_TABLE_HH

#include "hb-open-type.hh"

#include "hb-ot-layout-common.hh"

/*

 * STAT -- Style Attributes

 * https://docs.microsoft.com/en-us/typography/opentype/spec/stat

 */

#define HB_OT_TAG_STAT HB_TAG('S','T','A','T')

namespace OT {

enum

{

  OLDER_SIBLING_FONT_ATTRIBUTE = 0x0001,  /* If set, this axis value table

             * provides axis value information

             * that is applicable to other fonts

             * within the same font family. This

             * is used if the other fonts were

             * released earlier and did not include

             * information about values for some axis.

             * If newer versions of the other

             * fonts include the information

             * themselves and are present,

             * then this record is ignored. */

  ELIDABLE_AXIS_VALUE_NAME = 0x0002   /* If set, it indicates that the axis

             * value represents the “normal” value

             * for the axis and may be omitted when

             * composing name strings. */

  // Reserved = 0xFFFC        /* Reserved for future use — set to zero. */

};

static bool axis_value_is_outside_axis_range (hb_tag_t axis_tag, float axis_value,

                                              const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location)

{

  if (!user_axes_location->has (axis_tag))

    return false;

  Triple axis_range = user_axes_location->get (axis_tag);

  return (axis_value < axis_range.minimum || axis_value > axis_range.maximum);

}

struct StatAxisRecord

{

  int cmp (hb_tag_t key) const { return tag.cmp (key); }

  hb_ot_name_id_t get_name_id () const { return nameID; }

  hb_tag_t get_axis_tag () const { return tag; }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this)));

  }

  protected:

  Tag   tag;    /* A tag identifying the axis of design variation. */

  NameID  nameID;   /* The name ID for entries in the 'name' table that

         * provide a display string for this axis. */

  HBUINT16  ordering; /* A value that applications can use to determine

         * primary sorting of face names, or for ordering

         * of descriptors when composing family or face names. */

  public:

  DEFINE_SIZE_STATIC (8);

};

struct AxisValueFormat1

{

  unsigned int get_axis_index () const { return axisIndex; }

  float get_value ()             const { return value.to_float (); }

  hb_ot_name_id_t get_value_name_id () const { return valueNameID; }

  hb_tag_t get_axis_tag (const hb_array_t<const StatAxisRecord> axis_records) const

  {

    unsigned axis_idx = get_axis_index ();

    return axis_records[axis_idx].get_axis_tag ();

  }

  bool keep_axis_value (const hb_array_t<const StatAxisRecord> axis_records,

                        const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location) const

  {

    hb_tag_t axis_tag = get_axis_tag (axis_records);

    float axis_value = get_value ();

    return !axis_value_is_outside_axis_range (axis_tag, axis_value, user_axes_location);

  }

  bool subset (hb_subset_context_t *c,

               const hb_array_t<const StatAxisRecord> axis_records) const

  {

    TRACE_SUBSET (this);

    const hb_hashmap_t<hb_tag_t, Triple>* user_axes_location = &c->plan->user_axes_location;

    if (keep_axis_value (axis_records, user_axes_location))

      return_trace (c->serializer->embed (this));

    return_trace (false);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  protected:

  HBUINT16  format;   /* Format identifier — set to 1. */

  HBUINT16  axisIndex;  /* Zero-base index into the axis record array

         * identifying the axis of design variation

         * to which the axis value record applies.

         * Must be less than designAxisCount. */

  HBUINT16  flags;    /* Flags — see below for details. */

  NameID  valueNameID;  /* The name ID for entries in the 'name' table

         * that provide a display string for this

         * attribute value. */

  F16DOT16  value;    /* A numeric value for this attribute value. */

  public:

  DEFINE_SIZE_STATIC (12);

};

struct AxisValueFormat2

{

  unsigned int get_axis_index () const { return axisIndex; }

  float get_value ()             const { return nominalValue.to_float (); }

  hb_ot_name_id_t get_value_name_id () const { return valueNameID; }

  hb_tag_t get_axis_tag (const hb_array_t<const StatAxisRecord> axis_records) const

  {

    unsigned axis_idx = get_axis_index ();

    return axis_records[axis_idx].get_axis_tag ();

  }

  bool keep_axis_value (const hb_array_t<const StatAxisRecord> axis_records,

                        const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location) const

  {

    hb_tag_t axis_tag = get_axis_tag (axis_records);

    float axis_value = get_value ();

    return !axis_value_is_outside_axis_range (axis_tag, axis_value, user_axes_location);

  }

  bool subset (hb_subset_context_t *c,

               const hb_array_t<const StatAxisRecord> axis_records) const

  {

    TRACE_SUBSET (this);

    const hb_hashmap_t<hb_tag_t, Triple>* user_axes_location = &c->plan->user_axes_location;

    if (keep_axis_value (axis_records, user_axes_location))

      return_trace (c->serializer->embed (this));

    return_trace (false);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  protected:

  HBUINT16  format;   /* Format identifier — set to 2. */

  HBUINT16  axisIndex;  /* Zero-base index into the axis record array

         * identifying the axis of design variation

         * to which the axis value record applies.

         * Must be less than designAxisCount. */

  HBUINT16  flags;    /* Flags — see below for details. */

  NameID  valueNameID;  /* The name ID for entries in the 'name' table

         * that provide a display string for this

         * attribute value. */

  F16DOT16  nominalValue; /* A numeric value for this attribute value. */

  F16DOT16  rangeMinValue;  /* The minimum value for a range associated

         * with the specified name ID. */

  F16DOT16  rangeMaxValue;  /* The maximum value for a range associated

         * with the specified name ID. */

  public:

  DEFINE_SIZE_STATIC (20);

};

struct AxisValueFormat3

{

  unsigned int get_axis_index () const { return axisIndex; }

  float get_value ()             const { return value.to_float (); }

  hb_ot_name_id_t get_value_name_id () const { return valueNameID; }

  hb_tag_t get_axis_tag (const hb_array_t<const StatAxisRecord> axis_records) const

  {

    unsigned axis_idx = get_axis_index ();

    return axis_records[axis_idx].get_axis_tag ();

  }

  bool keep_axis_value (const hb_array_t<const StatAxisRecord> axis_records,

                        const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location) const

  {

    hb_tag_t axis_tag = get_axis_tag (axis_records);

    float axis_value = get_value ();

    return !axis_value_is_outside_axis_range (axis_tag, axis_value, user_axes_location);

  }

  bool subset (hb_subset_context_t *c,

               const hb_array_t<const StatAxisRecord> axis_records) const

  {

    TRACE_SUBSET (this);

    const hb_hashmap_t<hb_tag_t, Triple>* user_axes_location = &c->plan->user_axes_location;

    if (keep_axis_value (axis_records, user_axes_location))

      return_trace (c->serializer->embed (this));

    return_trace (false);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  protected:

  HBUINT16  format;   /* Format identifier — set to 3. */

  HBUINT16  axisIndex;  /* Zero-base index into the axis record array

         * identifying the axis of design variation

         * to which the axis value record applies.

         * Must be less than designAxisCount. */

  HBUINT16  flags;    /* Flags — see below for details. */

  NameID  valueNameID;  /* The name ID for entries in the 'name' table

         * that provide a display string for this

         * attribute value. */

  F16DOT16  value;    /* A numeric value for this attribute value. */

  F16DOT16  linkedValue;  /* The numeric value for a style-linked mapping

         * from this value. */

  public:

  DEFINE_SIZE_STATIC (16);

};

struct AxisValueRecord

{

  unsigned int get_axis_index () const { return axisIndex; }

  float get_value ()             const { return value.to_float (); }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  protected:

  HBUINT16  axisIndex;  /* Zero-base index into the axis record array

         * identifying the axis to which this value

         * applies. Must be less than designAxisCount. */

  F16DOT16  value;    /* A numeric value for this attribute value. */

  public:

  DEFINE_SIZE_STATIC (6);

};

struct AxisValueFormat4

{

  const AxisValueRecord &get_axis_record (unsigned int axis_index) const

  { return axisValues.as_array (axisCount)[axis_index]; }

  bool keep_axis_value (const hb_array_t<const StatAxisRecord> axis_records,

                        const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location) const

  {

    hb_array_t<const AxisValueRecord> axis_value_records = axisValues.as_array (axisCount);

    for (const auto& rec : axis_value_records)

    {

      unsigned axis_idx = rec.get_axis_index ();

      float axis_value = rec.get_value ();

      hb_tag_t axis_tag = axis_records[axis_idx].get_axis_tag ();

      if (axis_value_is_outside_axis_range (axis_tag, axis_value, user_axes_location))

        return false;

    }

    return true;

  }

  bool subset (hb_subset_context_t *c,

               const hb_array_t<const StatAxisRecord> axis_records) const

  {

    TRACE_SUBSET (this);

    const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location = &c->plan->user_axes_location;

    if (!keep_axis_value (axis_records, user_axes_location))

      return_trace (false);

    unsigned total_size = min_size + axisCount * AxisValueRecord::static_size;

    auto *out = c->serializer->allocate_size<AxisValueFormat4> (total_size);

    if (unlikely (!out)) return_trace (false);

    hb_memcpy (out, this, total_size);

    return_trace (true);

  }

  hb_ot_name_id_t get_value_name_id () const { return valueNameID; }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this) &&

        hb_barrier () &&

                          axisValues.sanitize (c, axisCount)));

  }

  protected:

  HBUINT16  format;   /* Format identifier — set to 4. */

  HBUINT16  axisCount;  /* The total number of axes contributing to

         * this axis-values combination. */

  HBUINT16  flags;    /* Flags — see below for details. */

  NameID  valueNameID;  /* The name ID for entries in the 'name' table

         * that provide a display string for this

         * attribute value. */

  UnsizedArrayOf<AxisValueRecord>

    axisValues; /* Array of AxisValue records that provide the

         * combination of axis values, one for each

         * contributing axis. */

  public:

  DEFINE_SIZE_ARRAY (8, axisValues);

};

struct AxisValue

{

  float get_value (unsigned int axis_index) const

  {

    switch (u.format)

    {

    case 1: return u.format1.get_value ();

    case 2: return u.format2.get_value ();

    case 3: return u.format3.get_value ();

    case 4: return u.format4.get_axis_record (axis_index).get_value ();

    default:return 0.f;

    }

  }

  unsigned int get_axis_index () const

  {

    switch (u.format)

    {

    case 1: return u.format1.get_axis_index ();

    case 2: return u.format2.get_axis_index ();

    case 3: return u.format3.get_axis_index ();

    /* case 4: Makes more sense for variable fonts which are handled by fvar in hb-style */

    default:return -1;

    }

  }

  hb_ot_name_id_t get_value_name_id () const

  {

    switch (u.format)

    {

    case 1: return u.format1.get_value_name_id ();

    case 2: return u.format2.get_value_name_id ();

    case 3: return u.format3.get_value_name_id ();

    case 4: return u.format4.get_value_name_id ();

    default:return HB_OT_NAME_ID_INVALID;

    }

  }

  template <typename context_t, typename ...Ts>

  typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const

  {

    if (unlikely (!c->may_dispatch (this, &u.format))) return c->no_dispatch_return_value ();

    TRACE_DISPATCH (this, u.format);

    switch (u.format) {

    case 1: return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));

    case 2: return_trace (c->dispatch (u.format2, std::forward<Ts> (ds)...));

    case 3: return_trace (c->dispatch (u.format3, std::forward<Ts> (ds)...));

    case 4: return_trace (c->dispatch (u.format4, std::forward<Ts> (ds)...));

    default:return_trace (c->default_return_value ());

    }

  }

  bool keep_axis_value (const hb_array_t<const StatAxisRecord> axis_records,

                        hb_hashmap_t<hb_tag_t, Triple> *user_axes_location) const

  {

    switch (u.format)

    {

    case 1: return u.format1.keep_axis_value (axis_records, user_axes_location);

    case 2: return u.format2.keep_axis_value (axis_records, user_axes_location);

    case 3: return u.format3.keep_axis_value (axis_records, user_axes_location);

    case 4: return u.format4.keep_axis_value (axis_records, user_axes_location);

    default:return false;

    }

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    if (unlikely (!c->check_struct (this)))

      return_trace (false);

    hb_barrier ();

    switch (u.format)

    {

    case 1: return_trace (u.format1.sanitize (c));

    case 2: return_trace (u.format2.sanitize (c));

    case 3: return_trace (u.format3.sanitize (c));

    case 4: return_trace (u.format4.sanitize (c));

    default:return_trace (true);

    }

  }

  protected:

  union

  {

  HBUINT16    format;

  AxisValueFormat1  format1;

  AxisValueFormat2  format2;

  AxisValueFormat3  format3;

  AxisValueFormat4  format4;

  } u;

  public:

  DEFINE_SIZE_UNION (2, format);

};

struct AxisValueOffsetArray: UnsizedArrayOf<Offset16To<AxisValue>>

{

  bool subset (hb_subset_context_t *c,

               unsigned axisValueCount,

               unsigned& count,

               const hb_array_t<const StatAxisRecord> axis_records) const

  {

    TRACE_SUBSET (this);

    auto axisValueOffsets = as_array (axisValueCount);

    count = 0;

    for (const auto& offset : axisValueOffsets)

    {

      if (!offset) continue;

      auto o_snap = c->serializer->snapshot ();

      auto *o = c->serializer->embed (offset);

      if (!o) return_trace (false);

      if (!o->serialize_subset (c, offset, this, axis_records))

      {

        c->serializer->revert (o_snap);

        continue;

      }

      count++;

    }

    return_trace (count);

  }

};

struct STAT

{

  static constexpr hb_tag_t tableTag = HB_OT_TAG_STAT;

  bool has_data () const { return version.to_int (); }

  bool get_value (hb_tag_t tag, float *value) const

  {

    unsigned int axis_index;

    if (!get_design_axes ().lfind (tag, &axis_index)) return false;

    hb_array_t<const Offset16To<AxisValue>> axis_values = get_axis_value_offsets ();

    for (unsigned int i = 0; i < axis_values.length; i++)

    {

      const AxisValue& axis_value = this+offsetToAxisValueOffsets+axis_values[i];

      if (axis_value.get_axis_index () == axis_index)

      {

  if (value)

    *value = axis_value.get_value (axis_index);

  return true;

      }

    }

    return false;

  }

  unsigned get_design_axis_count () const { return designAxisCount; }

  hb_ot_name_id_t get_axis_record_name_id (unsigned axis_record_index) const

  {

    if (unlikely (axis_record_index >= designAxisCount)) return HB_OT_NAME_ID_INVALID;

    const StatAxisRecord &axis_record = get_design_axes ()[axis_record_index];

    return axis_record.get_name_id ();

  }

  unsigned get_axis_value_count () const { return axisValueCount; }

  hb_ot_name_id_t get_axis_value_name_id (unsigned axis_value_index) const

  {

    if (unlikely (axis_value_index >= axisValueCount)) return HB_OT_NAME_ID_INVALID;

    const AxisValue &axis_value = (this + get_axis_value_offsets ()[axis_value_index]);

    return axis_value.get_value_name_id ();

  }

  void collect_name_ids (hb_hashmap_t<hb_tag_t, Triple> *user_axes_location,

                         hb_set_t *nameids_to_retain /* OUT */) const

  {

    if (!has_data ()) return;

    + get_design_axes ()

    | hb_map (&StatAxisRecord::get_name_id)

    | hb_sink (nameids_to_retain)

    ;

    auto designAxes = get_design_axes ();

    + get_axis_value_offsets ()

    | hb_map (hb_add (&(this + offsetToAxisValueOffsets)))

    | hb_filter ([&] (const AxisValue& _)

                 { return _.keep_axis_value (designAxes, user_axes_location); })

    | hb_map (&AxisValue::get_value_name_id)

    | hb_sink (nameids_to_retain)

    ;

    nameids_to_retain->add (elidedFallbackNameID);

  }

  bool subset (hb_subset_context_t *c) const

  {

    TRACE_SUBSET (this);

    STAT *out = c->serializer->embed (this);

    if (unlikely (!out)) return_trace (false);

    auto designAxes = get_design_axes ();

    for (unsigned i = 0; i < (unsigned)designAxisCount; i++)

      if (unlikely (!c->serializer->embed (designAxes[i])))

          return_trace (false);

    if (designAxisCount)

      c->serializer->check_assign (out->designAxesOffset, this->get_size (),

                                   HB_SERIALIZE_ERROR_INT_OVERFLOW);

    unsigned count = 0;

    out->offsetToAxisValueOffsets.serialize_subset (c, offsetToAxisValueOffsets, this,

                                                    axisValueCount, count, designAxes);

    return_trace (c->serializer->check_assign (out->axisValueCount, count, HB_SERIALIZE_ERROR_INT_OVERFLOW));

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this) &&

        hb_barrier () &&

        version.major == 1 &&

        version.minor > 0 &&

        designAxesOffset.sanitize (c, this, designAxisCount) &&

        offsetToAxisValueOffsets.sanitize (c, this, axisValueCount, &(this+offsetToAxisValueOffsets))));

  }

  protected:

  hb_array_t<const StatAxisRecord> const get_design_axes () const

  { return (this+designAxesOffset).as_array (designAxisCount); }

  hb_array_t<const Offset16To<AxisValue>> const get_axis_value_offsets () const

  { return (this+offsetToAxisValueOffsets).as_array (axisValueCount); }

  protected:

  FixedVersion<>version;  /* Version of the stat table

         * initially set to 0x00010002u */

  HBUINT16  designAxisSize; /* The size in bytes of each axis record. */

  HBUINT16  designAxisCount;/* The number of design axis records. In a

         * font with an 'fvar' table, this value must be

         * greater than or equal to the axisCount value

         * in the 'fvar' table. In all fonts, must

         * be greater than zero if axisValueCount

         * is greater than zero. */

  NNOffset32To<UnsizedArrayOf<StatAxisRecord>>

    designAxesOffset;

        /* Offset in bytes from the beginning of

         * the STAT table to the start of the design

         * axes array. If designAxisCount is zero,

         * set to zero; if designAxisCount is greater

         * than zero, must be greater than zero. */

  HBUINT16  axisValueCount; /* The number of axis value tables. */

  NNOffset32To<AxisValueOffsetArray>

    offsetToAxisValueOffsets;

        /* Offset in bytes from the beginning of

         * the STAT table to the start of the design

         * axes value offsets array. If axisValueCount

         * is zero, set to zero; if axisValueCount is

         * greater than zero, must be greater than zero. */

  NameID  elidedFallbackNameID;

        /* Name ID used as fallback when projection of

         * names into a particular font model produces

         * a subfamily name containing only elidable

         * elements. */

  public:

  DEFINE_SIZE_STATIC (20);

};

} /* namespace OT */

#endif /* HB_OT_STAT_TABLE_HH */