/*
 * 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_FONT_FACTORY_H_
#define SFNTLY_CPP_SRC_SFNTLY_FONT_FACTORY_H_

#include <vector>

#include "sfntly/port/refcount.h"
#include "sfntly/port/type.h"
#include "sfntly/font.h"

namespace sfntly {

class FontFactory : public RefCounted<FontFactory> {
 public:
  virtual ~FontFactory();

  // Factory method for the construction of a font factory.
  static CALLER_ATTACH FontFactory* GetInstance();

  // Toggle whether fonts that are loaded are fingerprinted with a SHA-1 hash.
  // If a font is fingerprinted then a SHA-1 hash is generated at load time and
  // stored in the font. This is useful for uniquely identifying fonts. By
  // default this is turned on.
  // @param fingerprint whether fingerprinting should be turned on or off
  // TODO(arthurhsu): IMPLEMENT: C++ port currently don't do any SHA-1
  void FingerprintFont(bool fingerprint);
  bool FingerprintFont();

  // Load the font(s) from the input stream. The current settings on the factory
  // are used during the loading process. One or more fonts are returned if the
  // stream contains valid font data. Some font container formats may have more
  // than one font and in this case multiple font objects will be returned. If
  // the data in the stream cannot be parsed or is invalid an array of size zero
  // will be returned.
  void LoadFonts(InputStream* is, FontArray* output);

  // ByteArray font loading
  // Load the font(s) from the byte array. The current settings on the factory
  // are used during the loading process. One or more fonts are returned if the
  // stream contains valid font data. Some font container formats may have more
  // than one font and in this case multiple font objects will be returned. If
  // the data in the stream cannot be parsed or is invalid an array of size zero
  // will be returned.
  void LoadFonts(ByteVector* b, FontArray* output);

  // Load the font(s) from the input stream into font builders. The current
  // settings on the factory are used during the loading process. One or more
  // font builders are returned if the stream contains valid font data. Some
  // font container formats may have more than one font and in this case
  // multiple font builder objects will be returned. If the data in the stream
  // cannot be parsed or is invalid an array of size zero will be returned.
  void LoadFontsForBuilding(InputStream* is, FontBuilderArray* output);

  // Load the font(s) from the byte array into font builders. The current
  // settings on the factory are used during the loading process. One or more
  // font builders are returned if the stream contains valid font data. Some
  // font container formats may have more than one font and in this case
  // multiple font builder objects will be returned. If the data in the stream
  // cannot be parsed or is invalid an array of size zero will be returned.
  void LoadFontsForBuilding(ByteVector* b, FontBuilderArray* output);

  // Font serialization
  // Serialize the font to the output stream.
  // NOTE: in this port we attempted not to implement I/O stream because dealing
  //       with cross-platform I/O stream itself is big enough as a project.
  //       Byte buffer it is.
  void SerializeFont(Font* font, OutputStream* os);

  // Set the table ordering to be used in serializing a font. The table ordering
  // is an ordered list of table ids and tables will be serialized in the order
  // given. Any tables whose id is not listed in the ordering will be placed in
  // an unspecified order following those listed.
  void SetSerializationTableOrdering(const IntegerList& table_ordering);

  // Get an empty font builder for creating a new font from scratch.
  CALLER_ATTACH Font::Builder* NewFontBuilder();

 private:
  // Offsets to specific elements in the underlying data. These offsets are
  // relative to the start of the table or the start of sub-blocks within the
  // table.
  struct Offset {
    enum {
      // Offsets within the main directory.
      kTTCTag = 0,
      kVersion = 4,
      kNumFonts = 8,
      kOffsetTable = 12,

      // TTC Version 2.0 extensions.
      // Offsets from end of OffsetTable.
      kulDsigTag = 0,
      kulDsigLength = 4,
      kulDsigOffset = 8
    };
  };

  FontFactory();

  CALLER_ATTACH Font* LoadSingleOTF(InputStream* is);
  CALLER_ATTACH Font* LoadSingleOTF(WritableFontData* wfd);

  void LoadCollection(InputStream* is, FontArray* output);
  void LoadCollection(WritableFontData* wfd, FontArray* output);

  CALLER_ATTACH Font::Builder* LoadSingleOTFForBuilding(InputStream* is);
  CALLER_ATTACH Font::Builder*
      LoadSingleOTFForBuilding(WritableFontData* wfd,
                               int32_t offset_to_offset_table);

  void LoadCollectionForBuilding(InputStream* is, FontBuilderArray* builders);
  void LoadCollectionForBuilding(WritableFontData* ba,
                                 FontBuilderArray* builders);

  static bool IsCollection(PushbackInputStream* pbis);
  static bool IsCollection(ReadableFontData* wfd);

  bool fingerprint_;
  IntegerList table_ordering_;
};
typedef Ptr<FontFactory> FontFactoryPtr;

}  // namespace sfntly

#endif  // SFNTLY_CPP_SRC_SFNTLY_FONT_FACTORY_H_