/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "graphite2/Font.h"
#include "graphite2/Segment.h"
#include "graphite2/GraphiteExtra.h"
#include "mozilla/Utf16.h"

#include <stdlib.h>
#include <memory>
#include <limits>

#define CHECK(cond, str) \
  do {                   \
    if (!(cond)) {       \
      return false;      \
    }                    \
  } while (false)

#define IS_POWER_OF_2(n) (n & (n - 1)) == 0

typedef gr_glyph_to_char_cluster Cluster;

// returns whether successful
static bool LoopThrough(gr_segment* aSegment, const uint32_t aLength,
                        const uint32_t aGlyphCount, const char16_t* aText,
                        uint32_t& aCIndex, Cluster* aClusters, uint16_t* aGids,
                        float* aXLocs, float* aYLocs) {
  // walk through the glyph slots and check which original character
  // each is associated with
  uint32_t gIndex = 0;  // glyph slot index
  for (const gr_slot* slot = gr_seg_first_slot(aSegment); slot != nullptr;
       slot = gr_slot_next_in_segment(slot), gIndex++) {
    CHECK(gIndex < aGlyphCount, "iterating past glyphcount");
    uint32_t before =
        gr_cinfo_base(gr_seg_cinfo(aSegment, gr_slot_before(slot)));
    uint32_t after = gr_cinfo_base(gr_seg_cinfo(aSegment, gr_slot_after(slot)));
    aGids[gIndex] = gr_slot_gid(slot);
    aXLocs[gIndex] = gr_slot_origin_X(slot);
    aYLocs[gIndex] = gr_slot_origin_Y(slot);

    // if this glyph has a "before" character index that precedes the
    // current cluster's char index, we need to merge preceding
    // aClusters until it gets included
    while (before < aClusters[aCIndex].baseChar && aCIndex > 0) {
      aClusters[aCIndex - 1].nChars += aClusters[aCIndex].nChars;
      aClusters[aCIndex - 1].nGlyphs += aClusters[aCIndex].nGlyphs;
      --aCIndex;
    }

    // if there's a gap between the current cluster's base character and
    // this glyph's, extend the cluster to include the intervening chars
    if (gr_slot_can_insert_before(slot) && aClusters[aCIndex].nChars &&
        before >= aClusters[aCIndex].baseChar + aClusters[aCIndex].nChars) {
      CHECK(aCIndex < aLength - 1, "aCIndex at end of word");
      Cluster& c = aClusters[aCIndex + 1];
      c.baseChar = aClusters[aCIndex].baseChar + aClusters[aCIndex].nChars;
      c.nChars = before - c.baseChar;
      c.baseGlyph = gIndex;
      c.nGlyphs = 0;
      ++aCIndex;
    }

    // increment cluster's glyph count to include current slot
    CHECK(aCIndex < aLength, "aCIndex beyond word length");
    ++aClusters[aCIndex].nGlyphs;

    // bump |after| index if it falls in the middle of a surrogate pair
    if (mozilla::IsHighSurrogate(aText[after]) && after < aLength - 1 &&
        mozilla::IsLowSurrogate(aText[after + 1])) {
      after++;
    }

    // extend cluster if necessary to reach the glyph's "after" index
    if (aClusters[aCIndex].baseChar + aClusters[aCIndex].nChars < after + 1) {
      aClusters[aCIndex].nChars = after + 1 - aClusters[aCIndex].baseChar;
    }
  }

  // Succeeded
  return true;
}

static gr_glyph_to_char_association* calloc_glyph_to_char_association(
    uint32_t aGlyphCount, uint32_t aLength) {
  using Type1 = gr_glyph_to_char_association;
  using Type2 = gr_glyph_to_char_cluster;
  using Type3 = float;
  using Type4 = float;
  using Type5 = uint16_t;

  // We are allocating memory in a pool. To avoid dealing with thorny alignment
  // issues, we allocate from most to least aligned
  static_assert(
      alignof(Type1) >= alignof(Type2) && alignof(Type2) >= alignof(Type3) &&
          alignof(Type3) >= alignof(Type4) && alignof(Type4) >= alignof(Type5),
      "Unexpected alignments of types");

  const uint64_t size1 = sizeof(Type1) * static_cast<uint64_t>(1);
  const uint64_t size2 = sizeof(Type2) * static_cast<uint64_t>(aLength);
  const uint64_t size3 = sizeof(Type3) * static_cast<uint64_t>(aGlyphCount);
  const uint64_t size4 = sizeof(Type4) * static_cast<uint64_t>(aGlyphCount);
  const uint64_t size5 = sizeof(Type5) * static_cast<uint64_t>(aGlyphCount);

  uint64_t totalSize = size1 + size2 + size3 + size4 + size5;

  if (totalSize > std::numeric_limits<uint32_t>::max()) {
    // allocation request got too large
    return nullptr;
  }

  char* const memoryPool = static_cast<char*>(calloc(1, totalSize));
  if (!memoryPool) {
    return nullptr;
  }

  char* currentPoolFront = memoryPool;

  auto data = reinterpret_cast<Type1*>(currentPoolFront);
  currentPoolFront += size1;
  data->clusters = reinterpret_cast<Type2*>(currentPoolFront);
  currentPoolFront += size2;
  data->xLocs = reinterpret_cast<Type3*>(currentPoolFront);
  currentPoolFront += size3;
  data->yLocs = reinterpret_cast<Type4*>(currentPoolFront);
  currentPoolFront += size4;
  data->gids = reinterpret_cast<Type5*>(currentPoolFront);

  return data;
}

// returns nullptr on failure and the glyph to char association on success
gr_glyph_to_char_association* gr_get_glyph_to_char_association(
    gr_segment* aSegment, uint32_t aLength, const char16_t* aText) {
  uint32_t glyphCount = gr_seg_n_slots(aSegment);

  gr_glyph_to_char_association* data =
      calloc_glyph_to_char_association(glyphCount, aLength);
  if (!data) {
    return nullptr;
  }

  bool succeeded =
      LoopThrough(aSegment, aLength, glyphCount, aText, data->cIndex,
                  data->clusters, data->gids, data->xLocs, data->yLocs);
  if (!succeeded) {
    gr_free_char_association(data);
    return nullptr;
  }
  return data;
}

void gr_free_char_association(gr_glyph_to_char_association* aData) {
  free(aData);
}

#undef CHECK
#undef IS_POWER_OF_2