// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chromeos/components/quick_answers/search_result_parsers/definition_result_parser.h"

#include <optional>
#include <string>

#include "base/logging.h"
#include "base/values.h"
#include "chromeos/components/quick_answers/quick_answers_model.h"
#include "chromeos/components/quick_answers/utils/quick_answers_utils.h"
#include "url/gurl.h"

namespace quick_answers {
namespace {

using base::Value;

constexpr char kHttpsPrefix[] = "https:";

// DictionaryResult
constexpr char kDictionaryResultKey[] = "dictionaryResult";
constexpr char kQueryTermKey[] = "queryTerm";
constexpr char kEntriesKey[] = "entries";

// Entry
constexpr char kHeadwordKey[] = "headword";
constexpr char kLocaleKey[] = "locale";
constexpr char kPhoneticsKey[] = "phonetics";
constexpr char kSenseFamiliesKey[] = "senseFamilies";

// Phonetics
constexpr char kPhoneticsTextKey[] = "text";
constexpr char kPhoneticsAudioKey[] = "oxfordAudio";
constexpr char kPhoneticsTtsAudioEnabledKey[] = "ttsAudioEnabled";

// SenseFamilies
constexpr char kSensesKey[] = "senses";
constexpr char kPartsOfSpeechKey[] = "partsOfSpeech";

// Sense
constexpr char kDefinitionKey[] = "definition";
constexpr char kDefinitionTextKey[] = "text";
constexpr char kExampleGroupsKey[] = "exampleGroups";
constexpr char kExamplesKey[] = "examples";
constexpr char kAdditionalExamplesKey[] = "additionalExamples";
constexpr char kThesaurusEntriesKey[] = "thesaurusEntries";
constexpr char kSynonymsKey[] = "synonyms";
constexpr char kNymsKey[] = "nyms";
constexpr char kSynonymTextKey[] = "nym";
constexpr int kMaxSynonymsNumber = 3;

// SubSenses
constexpr char kSubSensesKey[] = "subsenses";
constexpr int kMaxSubSensesNumber = 3;

// PartsOfSpeech
constexpr char kPartsOfSpeechTextKey[] = "value";

std::string GetQueryTerm(const base::Value::Dict& result) {
  const std::string* query_term = result.FindString(kQueryTermKey);
  if (!query_term) {
    return std::string();
  }
  return *query_term;
}

std::string GetHeadword(const base::Value::Dict& entry_result) {
  const std::string* headword = entry_result.FindString(kHeadwordKey);
  if (!headword) {
    return std::string();
  }
  return *headword;
}

std::string GetSampleSentence(const base::Value::Dict& sense_result) {
  std::string sample_sentence;

  // Check both the `exampleGroups` and `additionalExamples` keys for a
  // sample sentence text.
  const base::Value::Dict* example_groups =
      ResultParser::GetFirstDictElementFromList(sense_result,
                                                kExampleGroupsKey);
  if (example_groups) {
    const Value::List* examples = example_groups->FindList(kExamplesKey);
    if (examples && !examples->empty()) {
      sample_sentence = examples->front().GetString();
    }
  }
  if (sample_sentence.empty()) {
    const Value::List* additional_examples =
        sense_result.FindList(kAdditionalExamplesKey);
    if (additional_examples && !additional_examples->empty()) {
      sample_sentence = additional_examples->front().GetString();
    }
  }

  return sample_sentence;
}

std::vector<std::string> GetSynonymsList(
    const base::Value::Dict& sense_result) {
  std::vector<std::string> synonyms_list;

  const base::Value::Dict* thesaurus_entries =
      ResultParser::GetFirstDictElementFromList(sense_result,
                                                kThesaurusEntriesKey);
  if (!thesaurus_entries) {
    return synonyms_list;
  }

  const base::Value::Dict* synonym_entries =
      ResultParser::GetFirstDictElementFromList(*thesaurus_entries,
                                                kSynonymsKey);
  if (!synonym_entries) {
    return synonyms_list;
  }

  const Value::List* nyms_entries = synonym_entries->FindList(kNymsKey);
  if (!nyms_entries) {
    return synonyms_list;
  }

  for (const base::Value& value : *nyms_entries) {
    // Stop after fetching the max number of synonyms.
    if (synonyms_list.size() == kMaxSynonymsNumber) {
      break;
    }

    const base::Value::Dict* nyms_entry = &(value.GetDict());
    if (nyms_entry->empty()) {
      continue;
    }

    const std::string* synonym_text = nyms_entry->FindString(kSynonymTextKey);
    if (synonym_text) {
      synonyms_list.push_back(*synonym_text);
    }
  }

  return synonyms_list;
}

std::unique_ptr<Sense> ParseSense(const base::Value::Dict& sense_result) {
  const base::Value::Dict* definition_entry =
      sense_result.FindDict(kDefinitionKey);
  if (!definition_entry) {
    DLOG(ERROR) << "Unable to find definition entry.";
    return nullptr;
  }

  const std::string* definition_text =
      definition_entry->FindString(kDefinitionTextKey);
  if (!definition_text) {
    DLOG(ERROR) << "Unable to find a text in a definition entry.";
    return nullptr;
  }

  std::unique_ptr<Sense> sense = std::make_unique<Sense>();
  sense->definition = ResultParser::RemoveKnownHtmlTags(*definition_text);

  const std::string sample_sentence = GetSampleSentence(sense_result);
  if (!sample_sentence.empty()) {
    sense->sample_sentence = ResultParser::RemoveKnownHtmlTags(sample_sentence);
  }

  const std::vector<std::string> synonyms_list = GetSynonymsList(sense_result);
  if (!synonyms_list.empty()) {
    sense->synonyms_list = std::move(synonyms_list);
  }

  return sense;
}

std::vector<Sense> ParseSubSenses(const base::Value::Dict& sense_result) {
  std::vector<Sense> subsenses_list;

  const Value::List* subsense_entries = sense_result.FindList(kSubSensesKey);
  if (!subsense_entries) {
    return subsenses_list;
  }

  for (const base::Value& value : *subsense_entries) {
    // Stop after fetching the max number of subsenses.
    if (subsenses_list.size() == kMaxSubSensesNumber) {
      break;
    }

    const base::Value::Dict* subsense_entry = &(value.GetDict());
    if (subsense_entry->empty()) {
      continue;
    }

    std::unique_ptr<Sense> subsense = ParseSense(*subsense_entry);
    if (!subsense) {
      continue;
    }

    subsenses_list.push_back(*subsense);
  }

  return subsenses_list;
}

}  // namespace

std::unique_ptr<StructuredResult>
DefinitionResultParser::ParseInStructuredResult(
    const base::Value::Dict& result) {
  const Value::Dict* dictionary_result = result.FindDict(kDictionaryResultKey);
  if (!dictionary_result) {
    DLOG(ERROR) << "Unable to find the dictionary result entry.";
    return nullptr;
  }

  const Value::Dict* first_entry = ResultParser::GetFirstDictElementFromList(
      *dictionary_result, kEntriesKey);
  if (!first_entry) {
    DLOG(ERROR) << "Unable to find a first entry.";
    return nullptr;
  }

  const Value::Dict* first_sense_family = ExtractFirstSenseFamily(*first_entry);
  if (!first_sense_family) {
    DLOG(ERROR) << "Unable to find a first sense familiy.";
    return nullptr;
  }

  const Value::Dict* first_sense = ResultParser::GetFirstDictElementFromList(
      *first_sense_family, kSensesKey);
  if (!first_sense) {
    DLOG(ERROR) << "Unable to find a first sense.";
    return nullptr;
  }

  std::unique_ptr<Sense> sense = ParseSense(*first_sense);
  if (!sense) {
    DLOG(ERROR) << "Unable to parse a sense.";
    return nullptr;
  }

  std::unique_ptr<DefinitionResult> definition_result =
      std::make_unique<DefinitionResult>();
  definition_result->sense = *(sense.get());

  const std::vector<Sense> subsenses_list = ParseSubSenses(*first_sense);
  if (!subsenses_list.empty()) {
    definition_result->subsenses_list = std::move(subsenses_list);
  }

  const Value::Dict* part_of_speech = ResultParser::GetFirstDictElementFromList(
      *first_sense_family, kPartsOfSpeechKey);
  if (!part_of_speech) {
    // For Spanish dictionary results, the |partsOfSpeech| field is found in
    // the individual sense information rather than in the sense family.
    // Try to find the |partsOfSpeech| for the |first_sense| since that is the
    // definition information we use for Quick Answers.
    part_of_speech = ResultParser::GetFirstDictElementFromList(
        *first_sense, kPartsOfSpeechKey);
    if (!part_of_speech) {
      DLOG(ERROR) << "Unable to find a part of speech.";
      return nullptr;
    }
  }

  const std::string* word_class =
      part_of_speech->FindString(kPartsOfSpeechTextKey);
  if (!word_class) {
    DLOG(ERROR) << "Unable to find a text in a part of speech entry.";
    return nullptr;
  }
  definition_result->word_class = *word_class;

  std::string word = GetQueryTerm(*dictionary_result);
  if (word.empty()) {
    word = GetHeadword(*first_entry);
    if (word.empty()) {
      DLOG(ERROR) << "Unable to find a word in either query term or headword.";
      return nullptr;
    }
  }
  definition_result->word = word;

  std::unique_ptr<PhoneticsInfo> phonetics_info =
      ParsePhoneticsInfo(*first_entry);
  if (phonetics_info) {
    definition_result->phonetics_info = *(phonetics_info.get());
  }

  std::unique_ptr<StructuredResult> structured_result =
      std::make_unique<StructuredResult>();
  structured_result->definition_result = std::move(definition_result);
  return structured_result;
}

bool DefinitionResultParser::PopulateQuickAnswer(
    const StructuredResult& structured_result,
    QuickAnswer* quick_answer) {
  DefinitionResult* definition_result =
      structured_result.definition_result.get();
  if (!definition_result) {
    DLOG(ERROR) << "Unable to find definition_result.";
    return false;
  }

  quick_answer->result_type = ResultType::kDefinitionResult;
  quick_answer->phonetics_info =
      structured_result.definition_result->phonetics_info;

  // Title line
  if (definition_result->word.empty()) {
    DLOG(ERROR) << "Unable to find a word in definition_result.";
    return false;
  }
  const std::string& title =
      !quick_answer->phonetics_info.text.empty()
          ? BuildDefinitionTitleText(definition_result->word,
                                     quick_answer->phonetics_info.text)
          : definition_result->word;
  quick_answer->title.push_back(std::make_unique<QuickAnswerText>(title));

  // Second line, i.e. definition.
  if (definition_result->sense.definition.empty()) {
    DLOG(ERROR) << "Unable to find a definition in a sense.";
    return false;
  }

  quick_answer->first_answer_row.push_back(
      std::make_unique<QuickAnswerResultText>(
          definition_result->sense.definition));
  return true;
}

bool DefinitionResultParser::SupportsNewInterface() const {
  return true;
}

bool DefinitionResultParser::Parse(const base::Value::Dict& result,
                                   QuickAnswer* quick_answer) {
  std::unique_ptr<StructuredResult> structured_result =
      ParseInStructuredResult(result);
  if (!structured_result) {
    return false;
  }

  return PopulateQuickAnswer(*structured_result, quick_answer);
}

const Value::Dict* DefinitionResultParser::ExtractFirstSenseFamily(
    const base::Value::Dict& definition_entry) {
  const Value::Dict* first_sense_family =
      ResultParser::GetFirstDictElementFromList(definition_entry,
                                                kSenseFamiliesKey);
  if (!first_sense_family) {
    DLOG(ERROR) << "Can't find a sense family.";
    return nullptr;
  }

  return first_sense_family;
}

const Value::Dict* DefinitionResultParser::ExtractFirstPhonetics(
    const base::Value::Dict& definition_entry) {
  const Value::Dict* first_phonetics =
      ResultParser::GetFirstDictElementFromList(definition_entry,
                                                kPhoneticsKey);
  if (first_phonetics)
    return first_phonetics;

  // It is is possible to have phonetics per sense family in case of heteronyms
  // such as "arithmetic".
  const Value::Dict* sense_family = ExtractFirstSenseFamily(definition_entry);
  if (sense_family)
    return ResultParser::GetFirstDictElementFromList(*sense_family,
                                                     kPhoneticsKey);

  DLOG(ERROR) << "Can't find a phonetics.";
  return nullptr;
}

std::unique_ptr<PhoneticsInfo> DefinitionResultParser::ParsePhoneticsInfo(
    const base::Value::Dict& entry_result) {
  const Value::Dict* first_phonetics = ExtractFirstPhonetics(entry_result);
  if (!first_phonetics) {
    DLOG(ERROR) << "Unable to find a first phonetics.";
    return nullptr;
  }

  std::unique_ptr<PhoneticsInfo> phonetics_info =
      std::make_unique<PhoneticsInfo>();

  const std::string* text = first_phonetics->FindString(kPhoneticsTextKey);
  if (text) {
    phonetics_info->text = *text;
  }

  // Check for the query text used for tts audio.
  const std::string headword = GetHeadword(entry_result);
  if (!headword.empty()) {
    phonetics_info->query_text = headword;
  }

  // Check for the locale used for tts audio.
  const std::string* locale = entry_result.FindString(kLocaleKey);
  if (locale) {
    phonetics_info->locale = *locale;
  }

  // Check if the phonetics has an audio URL.
  const std::string* audio_url =
      first_phonetics->FindString(kPhoneticsAudioKey);
  if (audio_url) {
    phonetics_info->phonetics_audio = GURL(kHttpsPrefix + *audio_url);
  }

  // Check if tts audio is enabled for the query.
  std::optional<bool> tts_audio_enabled =
      first_phonetics->FindBool(kPhoneticsTtsAudioEnabledKey);
  if (tts_audio_enabled && !tts_audio_enabled.value()) {
    phonetics_info->query_text.clear();
    phonetics_info->locale.clear();
  }
  return phonetics_info;
}

}  // namespace quick_answers