/*
 * Copyright 2011 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef SFNTLY_CPP_SRC_SFNTLY_TABLE_TRUETYPE_GLYPH_TABLE_H_
#define SFNTLY_CPP_SRC_SFNTLY_TABLE_TRUETYPE_GLYPH_TABLE_H_

#include <vector>

#include "sfntly/table/table.h"
#include "sfntly/table/subtable.h"
#include "sfntly/table/subtable_container_table.h"

namespace sfntly {

struct GlyphType {
  enum {
    kSimple = 0,
    kComposite = 1
  };
};

class GlyphTable : public SubTableContainerTable,
                   public RefCounted<GlyphTable> {
 public:
  class Builder;
  class Glyph : public SubTable {
   public:
    // Note: Contour is an empty class for the version ported
    class Contour {
     protected:
      Contour() {}
      virtual ~Contour() {}
    };

    class Builder : public SubTable::Builder {
     public:
      virtual ~Builder();

     protected:
      // Incoming table_builder is GlyphTable::Builder*.
      // Note: constructor refactored in C++ to avoid heavy lifting.
      //       caller need to do data->Slice(offset, length) beforehand.
      explicit Builder(WritableFontData* data);
      explicit Builder(ReadableFontData* data);

      static CALLER_ATTACH Builder*
          GetBuilder(GlyphTable::Builder* table_builder,
                     ReadableFontData* data);
      static CALLER_ATTACH Builder*
          GetBuilder(GlyphTable::Builder* table_builder,
                     ReadableFontData* data,
                     int32_t offset,
                     int32_t length);
      virtual void SubDataSet();
      virtual int32_t SubDataSizeToSerialize();
      virtual bool SubReadyToSerialize();
      virtual int32_t SubSerialize(WritableFontData* new_data);

     private:
      friend class GlyphTable::Builder;
    };

    virtual ~Glyph();
    static CALLER_ATTACH Glyph* GetGlyph(GlyphTable* table,
                                         ReadableFontData* data,
                                         int32_t offset,
                                         int32_t length);

    virtual int32_t Padding();
    virtual int32_t GlyphType();
    virtual int32_t NumberOfContours();
    virtual int32_t XMin();
    virtual int32_t XMax();
    virtual int32_t YMin();
    virtual int32_t YMax();

    virtual int32_t InstructionSize() = 0;
    virtual ReadableFontData* Instructions() = 0;

   protected:
    // Note: constructor refactored in C++ to avoid heavy lifting.
    //       caller need to do data->Slice(offset, length) beforehand.
    Glyph(ReadableFontData* data, int32_t glyph_type);
    virtual void Initialize() = 0;
    // Note: Derived class to define initialization_lock_.

   private:
    static int32_t GlyphType(ReadableFontData* data,
                             int32_t offset,
                             int32_t length);

    int32_t glyph_type_;
    int32_t number_of_contours_;
  };  // class GlyphTable::Glyph
  typedef Ptr<GlyphTable::Glyph::Builder> GlyphBuilderPtr;
  typedef std::vector<GlyphBuilderPtr> GlyphBuilderList;

  class Builder : public SubTableContainerTable::Builder,
                  public RefCounted<GlyphTable::Builder> {
   public:
    // Note: Constructor scope altered to public for base class to instantiate.
    Builder(Header* header, ReadableFontData* data);
    virtual ~Builder();

    virtual void SetLoca(const IntegerList& loca);
    virtual void GenerateLocaList(IntegerList* locas);

    static CALLER_ATTACH Builder* CreateBuilder(Header* header,
                                                WritableFontData* data);

    // Gets the List of glyph builders for the glyph table builder. These may be
    // manipulated in any way by the caller and the changes will be reflected in
    // the final glyph table produced.
    // If there is no current data for the glyph builder or the glyph builders
    // have not been previously set then this will return an empty glyph builder
    // List. If there is current data (i.e. data read from an existing font) and
    // the <code>loca</code> list has not been set or is null, empty, or
    // invalid, then an empty glyph builder List will be returned.
    GlyphBuilderList* GlyphBuilders();

    // Replace the internal glyph builders with the one provided. The provided
    // list and all contained objects belong to this builder.
    // This call is only required if the entire set of glyphs in the glyph
    // table builder are being replaced. If the glyph builder list provided from
    // the GlyphTable.Builder::GlyphBuilders() is being used and modified
    // then those changes will already be reflected in the glyph table builder.
    void SetGlyphBuilders(GlyphBuilderList* glyph_builders);

    // Glyph builder factories
    CALLER_ATTACH Glyph::Builder* GlyphBuilder(ReadableFontData* data);

   protected:  // internal API for building
    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
    virtual void SubDataSet();
    virtual int32_t SubDataSizeToSerialize();
    virtual bool SubReadyToSerialize();
    virtual int32_t SubSerialize(WritableFontData* new_data);

   private:
    void Initialize(ReadableFontData* data, const IntegerList& loca);
    GlyphBuilderList* GetGlyphBuilders();
    void Revert();

    GlyphBuilderList glyph_builders_;
    IntegerList loca_;
  };

  class SimpleGlyph : public Glyph, public RefCounted<SimpleGlyph> {
   public:
    static const int32_t kFLAG_ONCURVE;
    static const int32_t kFLAG_XSHORT;
    static const int32_t kFLAG_YSHORT;
    static const int32_t kFLAG_REPEAT;
    static const int32_t kFLAG_XREPEATSIGN;
    static const int32_t kFLAG_YREPEATSIGN;

    class SimpleContour : public Glyph::Contour {
     protected:
      SimpleContour() {}
      virtual ~SimpleContour() {}
    };

    class SimpleGlyphBuilder : public Glyph::Builder,
                               public RefCounted<SimpleGlyphBuilder> {
     public:
      virtual ~SimpleGlyphBuilder();

     protected:
      // Note: constructor refactored in C++ to avoid heavy lifting.
      //       caller need to do data->Slice(offset, length) beforehand.
      explicit SimpleGlyphBuilder(WritableFontData* data);
      explicit SimpleGlyphBuilder(ReadableFontData* data);
      virtual CALLER_ATTACH FontDataTable*
          SubBuildTable(ReadableFontData* data);

     private:
      friend class Glyph::Builder;
    };

    // Note: constructor refactored in C++ to avoid heavy lifting.
    //       caller need to do data->Slice(offset, length) beforehand.
    explicit SimpleGlyph(ReadableFontData* data);
    virtual ~SimpleGlyph();

    virtual int32_t InstructionSize();
    virtual CALLER_ATTACH ReadableFontData* Instructions();
    virtual void Initialize();

    int32_t NumberOfPoints(int32_t contour);
    int32_t XCoordinate(int32_t contour, int32_t point);
    int32_t YCoordinate(int32_t contour, int32_t point);
    bool OnCurve(int32_t contour, int32_t point);

   private:
    void ParseData(bool fill_arrays);
    int32_t FlagAsInt(int32_t index);
    int32_t ContourEndPoint(int32_t contour);

    bool initialized_;
    Lock initialization_lock_;
    int32_t instruction_size_;
    int32_t number_of_points_;

    // start offsets of the arrays
    int32_t instructions_offset_;
    int32_t flags_offset_;
    int32_t x_coordinates_offset_;
    int32_t y_coordinates_offset_;

    int32_t flag_byte_count_;
    int32_t x_byte_count_;
    int32_t y_byte_count_;

    IntegerList x_coordinates_;
    IntegerList y_coordinates_;
    std::vector<bool> on_curve_;
    IntegerList contour_index_;
  };

  class CompositeGlyph : public Glyph, public RefCounted<CompositeGlyph> {
   public:
    static const int32_t kFLAG_ARG_1_AND_2_ARE_WORDS;
    static const int32_t kFLAG_ARGS_ARE_XY_VALUES;
    static const int32_t kFLAG_ROUND_XY_TO_GRID;
    static const int32_t kFLAG_WE_HAVE_A_SCALE;
    static const int32_t kFLAG_RESERVED;
    static const int32_t kFLAG_MORE_COMPONENTS;
    static const int32_t kFLAG_WE_HAVE_AN_X_AND_Y_SCALE;
    static const int32_t kFLAG_WE_HAVE_A_TWO_BY_TWO;
    static const int32_t kFLAG_WE_HAVE_INSTRUCTIONS;
    static const int32_t kFLAG_USE_MY_METRICS;
    static const int32_t kFLAG_OVERLAP_COMPOUND;
    static const int32_t kFLAG_SCALED_COMPONENT_OFFSET;
    static const int32_t kFLAG_UNSCALED_COMPONENT_OFFSET;

    class CompositeGlyphBuilder : public Glyph::Builder,
                                  public RefCounted<CompositeGlyphBuilder> {
     public:
      virtual ~CompositeGlyphBuilder();

     protected:
      // Note: constructor refactored in C++ to avoid heavy lifting.
      //       caller need to do data->Slice(offset, length) beforehand.
      explicit CompositeGlyphBuilder(WritableFontData* data);
      explicit CompositeGlyphBuilder(ReadableFontData* data);

      virtual CALLER_ATTACH FontDataTable*
          SubBuildTable(ReadableFontData* data);

     private:
      friend class Glyph::Builder;
    };

    // Note: constructor refactored in C++ to avoid heavy lifting.
    //       caller need to do data->Slice(offset, length) beforehand.
    explicit CompositeGlyph(ReadableFontData* data);
    virtual ~CompositeGlyph();

    int32_t Flags(int32_t contour);
    int32_t NumGlyphs();
    int32_t GlyphIndex(int32_t contour);
    int32_t Argument1(int32_t contour);
    int32_t Argument2(int32_t contour);
    int32_t TransformationSize(int32_t contour);
    void Transformation(int32_t contour, ByteVector* transformation);
    virtual int32_t InstructionSize();
    virtual CALLER_ATTACH ReadableFontData* Instructions();

   protected:
    virtual void Initialize();

   private:
    IntegerList contour_index_;
    int32_t instruction_size_;
    int32_t instructions_offset_;
    bool initialized_;
    Lock initialization_lock_;
  };

  virtual ~GlyphTable();

  // C++ port: rename glyph() to GetGlyph().
  Glyph* GetGlyph(int32_t offset, int32_t length);

 private:
  struct Offset {
    enum {
      // header
      kNumberOfContours = 0,
      kXMin = 2,
      kYMin = 4,
      kXMax = 6,
      kYMax = 8,

      // Simple Glyph Description
      kSimpleEndPtsOfCountours = 10,
      // offset from the end of the contours array
      kSimpleInstructionLength = 0,
      kSimpleInstructions = 2,
      // flags
      // xCoordinates
      // yCoordinates

      // Composite Glyph Description
      kCompositeFlags = 0,
      kCompositeGyphIndexWithoutFlag = 0,
      kCompositeGlyphIndexWithFlag = 2,
    };
  };

  GlyphTable(Header* header, ReadableFontData* data);
};
typedef Ptr<GlyphTable> GlyphTablePtr;
typedef Ptr<GlyphTable::Builder> GlyphTableBuilderPtr;
typedef std::vector<GlyphTableBuilderPtr> GlyphTableBuilderList;
typedef Ptr<GlyphTable::Glyph> GlyphPtr;
typedef Ptr<GlyphTable::Glyph::Builder> GlyphBuilderPtr;

}  // namespace sfntly

#endif  // SFNTLY_CPP_SRC_SFNTLY_TABLE_TRUETYPE_GLYPH_TABLE_H_