// Copyright 2016 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.

#include "cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontMgr_cobalt.h"

#include "base/debug/trace_event.h"
#include "cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontConfigParser_cobalt.h"
#include "cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.h"
#include "SkData.h"
#include "SkStream.h"
#include "SkString.h"
#include "SkTSearch.h"

SkFontMgr_Cobalt::SkFontMgr_Cobalt(
    const char* directory, const SkTArray<SkString, true>& default_families)
    : system_typeface_stream_manager_(
          "Font.SystemTypeface",
          COBALT_SYSTEM_TYPEFACE_CACHE_CAPACITY_IN_BYTES),
      default_family_(NULL) {
  TRACE_EVENT0("cobalt::renderer", "SkFontMgr_Cobalt::SkFontMgr_Cobalt()");

  SkTDArray<FontFamily*> font_families;
  {
    TRACE_EVENT0("cobalt::renderer", "SkFontConfigParser::GetFontFamilies()");
    SkFontConfigParser::GetFontFamilies(directory, &font_families);
  }
  BuildNameToFamilyMap(directory, &font_families);
  font_families.deleteAll();

  FindDefaultFamily(default_families);
}

SkTypeface* SkFontMgr_Cobalt::MatchFaceName(const char face_name[]) {
  if (!face_name) {
    return NULL;
  }

  SkAutoAsciiToLC face_name_to_lc(face_name);
  std::string face_name_string(face_name_to_lc.lc(), face_name_to_lc.length());

  // Lock the style sets mutex prior to accessing them.
  SkAutoMutexAcquire scoped_mutex(style_sets_mutex_);

  // Prioritize looking up the postscript name first since some of our client
  // applications prefer this method to specify face names.
  for (int i = 0; i <= 1; ++i) {
    NameToStyleSetMap& name_to_style_set_map =
        i == 0 ? font_postscript_name_to_style_set_map_
               : full_font_name_to_style_set_map_;

    NameToStyleSetMap::iterator style_set_iterator =
        name_to_style_set_map.find(face_name_string);
    if (style_set_iterator != name_to_style_set_map.end()) {
      SkFontStyleSet_Cobalt* style_set = style_set_iterator->second;
      SkTypeface* typeface =
          i == 0 ? style_set->MatchFontPostScriptName(face_name_string)
                 : style_set->MatchFullFontName(face_name_string);
      if (typeface != NULL) {
        return typeface;
      } else {
        // If no typeface was successfully created then remove the entry from
        // the map. It won't provide a successful result in subsequent calls
        // either.
        name_to_style_set_map.erase(style_set_iterator);
      }
    }
  }
  return NULL;
}

int SkFontMgr_Cobalt::onCountFamilies() const { return family_names_.count(); }

void SkFontMgr_Cobalt::onGetFamilyName(int index, SkString* family_name) const {
  if (index < 0 || family_names_.count() <= index) {
    family_name->reset();
    return;
  }

  family_name->set(family_names_[index]);
}

SkFontStyleSet_Cobalt* SkFontMgr_Cobalt::onCreateStyleSet(int index) const {
  if (index < 0 || family_names_.count() <= index) {
    return NULL;
  }

  NameToStyleSetMap::const_iterator family_iterator =
      name_to_family_map_.find(family_names_[index].c_str());
  if (family_iterator != name_to_family_map_.end()) {
    return SkRef(family_iterator->second);
  }

  return NULL;
}

SkFontStyleSet_Cobalt* SkFontMgr_Cobalt::onMatchFamily(
    const char family_name[]) const {
  if (!family_name) {
    return NULL;
  }

  SkAutoAsciiToLC family_name_to_lc(family_name);

  NameToStyleSetMap::const_iterator family_iterator = name_to_family_map_.find(
      std::string(family_name_to_lc.lc(), family_name_to_lc.length()));
  if (family_iterator != name_to_family_map_.end()) {
    return SkRef(family_iterator->second);
  }

  return NULL;
}

SkTypeface* SkFontMgr_Cobalt::onMatchFamilyStyle(
    const char family_name[], const SkFontStyle& style) const {
  SkTypeface* typeface = NULL;

  if (family_name) {
    SkAutoTUnref<SkFontStyleSet> style_set(matchFamily(family_name));
    typeface = style_set->matchStyle(style);
  }

  if (NULL == typeface) {
    typeface = default_family_->matchStyle(style);
  }

  return typeface;
}

SkTypeface* SkFontMgr_Cobalt::onMatchFaceStyle(const SkTypeface* family_member,
                                               const SkFontStyle& style) const {
  // Lock the style sets mutex prior to calling private |SkFontStyleSet_Cobalt|
  // functions that expect the mutex to already be locked.
  SkAutoMutexAcquire scoped_mutex(style_sets_mutex_);

  for (int i = 0; i < font_style_sets_.count(); ++i) {
    if (font_style_sets_[i]->ContainsTypeface(family_member)) {
      return font_style_sets_[i]->MatchStyleWithoutLocking(style);
    }
  }
  return NULL;
}

SkTypeface* SkFontMgr_Cobalt::onMatchFamilyStyleCharacter(
    const char family_name[], const SkFontStyle& style, const char bcp47_val[],
    SkUnichar character) const {
  const char** bcp47 = &bcp47_val;
  int bcp47_count = bcp47_val ? 1 : 0;

  // Remove const from the manager. SkFontMgr_Cobalt modifies its internals
  // within FindFamilyStyleCharacter().
  SkFontMgr_Cobalt* font_mgr = const_cast<SkFontMgr_Cobalt*>(this);

  // Lock the style sets mutex prior to calling |FindFamilyStyleCharacter|. It
  // expects the mutex to already be locked.
  SkAutoMutexAcquire scoped_mutex(style_sets_mutex_);

  // Search the fallback families for ones matching the requested language.
  // They are given priority over other fallback families in checking for
  // character support.
  for (int bcp47_index = bcp47_count; bcp47_index-- > 0;) {
    SkLanguage language(bcp47[bcp47_index]);
    while (!language.GetTag().isEmpty()) {
      SkTypeface* matching_typeface = font_mgr->FindFamilyStyleCharacter(
          style, language.GetTag(), character);
      if (matching_typeface) {
        return matching_typeface;
      }

      language = language.GetParent();
    }
  }

  // Try to find character among all fallback families with no language
  // requirement. This will select the first encountered family that contains
  // the character.
  SkTypeface* matching_typeface =
      font_mgr->FindFamilyStyleCharacter(style, SkString(), character);

  // If no family was found that supports the character, then just fall back
  // to the default family.
  return matching_typeface ? matching_typeface
                           : default_family_->MatchStyleWithoutLocking(style);
}

SkTypeface* SkFontMgr_Cobalt::onCreateFromData(SkData* data,
                                               int face_index) const {
  SkAutoTUnref<SkStreamAsset> stream(new SkMemoryStream(data));
  return createFromStream(stream, face_index);
}

SkTypeface* SkFontMgr_Cobalt::onCreateFromStream(SkStreamAsset* stream,
                                                 int face_index) const {
  TRACE_EVENT0("cobalt::renderer", "SkFontMgr_Cobalt::onCreateFromStream()");
  bool is_fixed_pitch;
  SkTypeface::Style style;
  SkString name;
  if (!SkTypeface_FreeType::ScanFont(stream, face_index, &name, &style,
                                     &is_fixed_pitch)) {
    return NULL;
  }
  return SkNEW_ARGS(SkTypeface_CobaltStream,
                    (stream, face_index, style, is_fixed_pitch, name));
}

SkTypeface* SkFontMgr_Cobalt::onCreateFromFile(const char path[],
                                               int face_index) const {
  TRACE_EVENT0("cobalt::renderer", "SkFontMgr_Cobalt::onCreateFromFile()");
  SkAutoTUnref<SkStreamAsset> stream(SkStream::NewFromFile(path));
  return stream.get() ? createFromStream(stream, face_index) : NULL;
}

SkTypeface* SkFontMgr_Cobalt::onLegacyCreateTypeface(
    const char family_name[], unsigned style_bits) const {
  SkTypeface::Style old_style = (SkTypeface::Style)style_bits;
  SkFontStyle style = SkFontStyle(
      old_style & SkTypeface::kBold ? SkFontStyle::kBold_Weight
                                    : SkFontStyle::kNormal_Weight,
      SkFontStyle::kNormal_Width,
      old_style & SkTypeface::kItalic ? SkFontStyle::kItalic_Slant
                                      : SkFontStyle::kUpright_Slant);
  return matchFamilyStyle(family_name, style);
}

void SkFontMgr_Cobalt::BuildNameToFamilyMap(const char* base_path,
                                            SkTDArray<FontFamily*>* families) {
  TRACE_EVENT0("cobalt::renderer", "SkFontMgr_Cobalt::BuildNameToFamilyMap()");
  for (int i = 0; i < families->count(); i++) {
    FontFamily& family = *(*families)[i];
    bool named_family = family.names.count() > 0;

    if (family.is_fallback_family) {
      if (!named_family) {
        SkString& fallback_name = family.names.push_back();
        fallback_name.printf("%.2x##fallback", i);
      }
    }

    SkAutoTUnref<SkFontStyleSet_Cobalt> new_set(
        SkNEW_ARGS(SkFontStyleSet_Cobalt,
                   (family, base_path, &system_typeface_stream_manager_,
                    &style_sets_mutex_)));

    // Verify that the set successfully added entries.
    if (new_set->styles_.count() == 0) {
      continue;
    }

    font_style_sets_.push_back().reset(SkRef(new_set.get()));

    if (named_family) {
      for (int j = 0; j < family.names.count(); j++) {
        family_names_.push_back(family.names[j]);
        name_to_family_map_.insert(
            std::make_pair(family.names[j].c_str(), new_set.get()));
      }
    }

    if (family.is_fallback_family) {
      fallback_families_.push_back(new_set.get());
    }

    for (SkAutoTUnref<SkFontStyleSet_Cobalt::SkFontStyleSetEntry_Cobalt>*
             font_style_set_entry = new_set->styles_.begin();
         font_style_set_entry != new_set->styles_.end();
         ++font_style_set_entry) {
      // On the first pass through, process the full font name.
      // On the second pass through, process the font postscript name.
      for (int i = 0; i <= 1; ++i) {
        const std::string& font_face_name =
            i == 0 ? (*font_style_set_entry)->full_font_name
                   : (*font_style_set_entry)->font_postscript_name;
        // If there is no font face name for this style entry, then there's
        // nothing to add. Simply skip past it.
        if (font_face_name.empty()) {
          continue;
        }

        NameToStyleSetMap& font_face_name_style_set_map =
            i == 0 ? full_font_name_to_style_set_map_
                   : font_postscript_name_to_style_set_map_;

        if (font_face_name_style_set_map.find(font_face_name) ==
            font_face_name_style_set_map.end()) {
          font_face_name_style_set_map[font_face_name] = new_set.get();
        } else {
          // Purposely, not overwriting the entry gives priority to the
          // earlier entry.  This is consistent with how fonts.xml gives
          // priority to fonts that are specified earlier in the file.
          const std::string font_face_name_type =
              i == 0 ? "Full Font" : "Postscript";
          NOTREACHED() << font_face_name_type << " name [" << font_face_name
                       << "] already registered in BuildNameToFamilyMap.";
        }
      }
    }
  }
}

void SkFontMgr_Cobalt::FindDefaultFamily(
    const SkTArray<SkString, true>& default_families) {
  CHECK(!font_style_sets_.empty());

  for (size_t i = 0; i < default_families.count(); ++i) {
    SkAutoTUnref<SkFontStyleSet_Cobalt> check_style_set(
        onMatchFamily(default_families[i].c_str()));
    if (NULL == check_style_set) {
      continue;
    }

    SkAutoTUnref<SkTypeface> check_typeface(
        check_style_set->MatchStyleWithoutLocking(SkFontStyle()));
    if (NULL != check_typeface) {
      default_family_ = check_style_set.get();
      break;
    }
  }

  if (NULL == default_family_) {
    SkAutoTUnref<SkTypeface> check_typeface(
        font_style_sets_[0]->MatchStyleWithoutLocking(SkFontStyle()));
    if (NULL != check_typeface) {
      default_family_ = font_style_sets_[0].get();
    }
  }

  CHECK(default_family_);
}

SkTypeface* SkFontMgr_Cobalt::FindFamilyStyleCharacter(
    const SkFontStyle& style, const SkString& language_tag,
    SkUnichar character) {
  if (!font_character_map::IsCharacterValid(character)) {
    return NULL;
  }

  StyleSetArray* fallback_families = GetMatchingFallbackFamilies(language_tag);
  for (int i = 0; i < fallback_families->size(); ++i) {
    SkFontStyleSet_Cobalt* family = (*fallback_families)[i];
    if (family->ContainsCharacter(style, character)) {
      SkTypeface* matching_typeface = family->MatchStyleWithoutLocking(style);
      if (matching_typeface) {
        return matching_typeface;
      }
    }
  }

  return NULL;
}

SkFontMgr_Cobalt::StyleSetArray* SkFontMgr_Cobalt::GetMatchingFallbackFamilies(
    const SkString& language_tag) {
  if (language_tag.isEmpty()) {
    return &fallback_families_;
  }

  StyleSetArray*& language_fallback_families =
      language_fallback_families_map_[language_tag.c_str()];

  // The fallback families for a specific language tag are lazily populated. If
  // this is the first time that this tag has been encountered, then create and
  // populate the fallback families now.
  if (language_fallback_families == NULL) {
    language_fallback_families_array_.push_back(new StyleSetArray);
    language_fallback_families = *language_fallback_families_array_.rbegin();

    for (StyleSetArray::iterator iter = fallback_families_.begin();
         iter != fallback_families_.end(); ++iter) {
      SkFontStyleSet_Cobalt* fallback_family = *iter;
      if (fallback_family->language_.GetTag().startsWith(
              language_tag.c_str())) {
        language_fallback_families->push_back(fallback_family);
      }
    }
  }

  return language_fallback_families;
}