// Copyright 2010-2020, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "prediction/zero_query_dict.h"

#include <iterator>
#include <vector>

#include "base/port.h"
#include "base/serialized_string_array.h"
#include "testing/base/public/gunit.h"
#include "absl/strings/string_view.h"

namespace mozc {
namespace {

const char kTestTokenArray[] =
    // {"あ", "", ZERO_QUERY_EMOJI, EMOJI_DOCOMO | EMOJI_SOFTBANK, 0xfeb04}
    "\x04\x00\x00\x00"
    "\x00\x00\x00\x00"
    "\x03\x00"
    "\x06\x00"
    "\x04\xeb\x0f\x00"
    // {"あ", "❕", ZERO_QUERY_EMOJI, EMOJI_UNICODE, 0xfeb0b},
    "\x04\x00\x00\x00"
    "\x02\x00\x00\x00"
    "\x03\x00"
    "\x01\x00"
    "\x0b\xeb\x0f\x00"
    // {"あ", "❣", ZERO_QUERY_NONE, EMOJI_NONE, 0x00},
    "\x04\x00\x00\x00"
    "\x03\x00\x00\x00"
    "\x00\x00"
    "\x00\x00"
    "\x00\x00\x00\x00"
    // {"ああ", "( •̀ㅁ•́;)", ZERO_QUERY_EMOTICON, EMOJI_NONE, 0x00}
    "\x05\x00\x00\x00"
    "\x01\x00\x00\x00"
    "\x02\x00"
    "\x00\x00"
    "\x00\x00\x00\x00";

const char *kTestStrings[] = {
    "", "( •̀ㅁ•́;)", "❕", "❣", "あ", "ああ",
};

// Initializes a ZeroQueryDict from the above test data.  Note that the returned
// buffer contains the internal data used by |dict|, so it must outlive |dict|.
std::unique_ptr<uint32[]> InitTestZeroQueryDict(ZeroQueryDict *dict) {
  // kTestTokenArray contains a trailing '\0', so create a absl::string_view
  // that excludes it by subtracting 1.
  const absl::string_view token_array_data(kTestTokenArray,
                                           arraysize(kTestTokenArray) - 1);
  std::vector<absl::string_view> strs(std::begin(kTestStrings),
                                      std::end(kTestStrings));
  std::unique_ptr<uint32[]> string_data_buffer;
  const absl::string_view string_array_data =
      SerializedStringArray::SerializeToBuffer(strs, &string_data_buffer);
  dict->Init(token_array_data, string_array_data);
  return string_data_buffer;
}

void ExpectIterPointsToElem0(ZeroQueryDict::iterator iter) {
  EXPECT_EQ(4, iter.key_index());    // Index to "あ"
  EXPECT_EQ(0, iter.value_index());  // Index to ""
  EXPECT_EQ(ZERO_QUERY_EMOJI, iter.type());
  EXPECT_EQ(EMOJI_DOCOMO | EMOJI_SOFTBANK, iter.emoji_type());
  EXPECT_EQ(0xfeb04, iter.emoji_android_pua());
  EXPECT_EQ("あ", iter.key());
  EXPECT_EQ("", iter.value());
  EXPECT_EQ(4, *iter);    // Index to "あ"
  EXPECT_EQ(4, iter[0]);  // Index to "あ"
  EXPECT_EQ(4, iter[1]);  // Index to "あ"
  EXPECT_EQ(4, iter[2]);  // Index to "あ"
  EXPECT_EQ(5, iter[3]);  // Index to "ああ"
}

void ExpectIterPointsToElem1(ZeroQueryDict::iterator iter) {
  EXPECT_EQ(4, iter.key_index());    // Index to "あ"
  EXPECT_EQ(2, iter.value_index());  // Index to "❕"
  EXPECT_EQ(ZERO_QUERY_EMOJI, iter.type());
  EXPECT_EQ(EMOJI_UNICODE, iter.emoji_type());
  EXPECT_EQ(0xfeb0b, iter.emoji_android_pua());
  EXPECT_EQ("あ", iter.key());
  EXPECT_EQ("❕", iter.value());
  EXPECT_EQ(4, *iter);    // Index to "あ"
  EXPECT_EQ(4, iter[0]);  // Index to "あ"
  EXPECT_EQ(4, iter[1]);  // Index to "あ"
  EXPECT_EQ(5, iter[2]);  // Index to "ああ"
}

void ExpectIterPointsToElem2(ZeroQueryDict::iterator iter) {
  EXPECT_EQ(4, iter.key_index());    // Index to "あ"
  EXPECT_EQ(3, iter.value_index());  // Index to "❣"
  EXPECT_EQ(ZERO_QUERY_NONE, iter.type());
  EXPECT_EQ(EMOJI_NONE, iter.emoji_type());
  EXPECT_EQ(0x00, iter.emoji_android_pua());
  EXPECT_EQ("あ", iter.key());
  EXPECT_EQ("❣", iter.value());
  EXPECT_EQ(4, *iter);    // Index to "あ"
  EXPECT_EQ(4, iter[0]);  // Index to "あ"
  EXPECT_EQ(5, iter[1]);  // Index to "ああ"
}

void ExpectIterPointsToElem3(ZeroQueryDict::iterator iter) {
  EXPECT_EQ(5, iter.key_index());    // Index to "ああ"
  EXPECT_EQ(1, iter.value_index());  // Index to "( •̀ㅁ•́;)"
  EXPECT_EQ(ZERO_QUERY_EMOTICON, iter.type());
  EXPECT_EQ(EMOJI_NONE, iter.emoji_type());
  EXPECT_EQ(0x00, iter.emoji_android_pua());
  EXPECT_EQ("ああ", iter.key());
  EXPECT_EQ("( •̀ㅁ•́;)", iter.value());
  EXPECT_EQ(5, iter[0]);  // Index to "ああ"
}

TEST(ZeroQueryDictTest, IterateForwardByPreIncrement) {
  ZeroQueryDict dict;
  const auto buf = InitTestZeroQueryDict(&dict);
  ZeroQueryDict::iterator iter = dict.begin();
  ASSERT_NE(dict.end(), iter);
  ExpectIterPointsToElem0(iter);
  ASSERT_NE(dict.end(), ++iter);
  ExpectIterPointsToElem1(iter);
  ASSERT_NE(dict.end(), ++iter);
  ExpectIterPointsToElem2(iter);
  ASSERT_NE(dict.end(), ++iter);
  ExpectIterPointsToElem3(iter);
  ASSERT_EQ(dict.end(), ++iter);
}

TEST(ZeroQueryDictTest, IterateForwardByPostIncrement) {
  ZeroQueryDict dict;
  const auto buf = InitTestZeroQueryDict(&dict);
  ZeroQueryDict::iterator iter = dict.begin();
  ASSERT_NE(dict.end(), iter);
  ExpectIterPointsToElem0(iter++);
  ASSERT_NE(dict.end(), iter);
  ExpectIterPointsToElem1(iter++);
  ASSERT_NE(dict.end(), iter);
  ExpectIterPointsToElem2(iter++);
  ASSERT_NE(dict.end(), iter);
  ExpectIterPointsToElem3(iter++);
  ASSERT_EQ(dict.end(), iter);
}

TEST(ZeroQueryDictTest, IterateBackwardByPreDecrement) {
  ZeroQueryDict dict;
  const auto buf = InitTestZeroQueryDict(&dict);
  ZeroQueryDict::iterator iter = dict.end();
  ASSERT_NE(dict.begin(), --iter);
  ExpectIterPointsToElem3(iter);
  ASSERT_NE(dict.begin(), --iter);
  ExpectIterPointsToElem2(iter);
  ASSERT_NE(dict.begin(), --iter);
  ExpectIterPointsToElem1(iter);
  ASSERT_EQ(dict.begin(), --iter);
  ExpectIterPointsToElem0(iter);
}

TEST(ZeroQueryDictTest, IterateBackwardByPostDecrement) {
  ZeroQueryDict dict;
  const auto buf = InitTestZeroQueryDict(&dict);
  ZeroQueryDict::iterator iter = dict.end();
  EXPECT_EQ(dict.end(), iter--);
  ASSERT_NE(dict.begin(), iter);
  ExpectIterPointsToElem3(iter--);
  ASSERT_NE(dict.begin(), iter);
  ExpectIterPointsToElem2(iter--);
  ASSERT_NE(dict.begin(), iter);
  ExpectIterPointsToElem1(iter--);
  ASSERT_EQ(dict.begin(), iter);
  ExpectIterPointsToElem0(iter);
}

TEST(ZeroQueryDict, EqualRange) {
  ZeroQueryDict dict;
  const auto buf = InitTestZeroQueryDict(&dict);

  auto range = dict.equal_range("あ");
  EXPECT_EQ(dict.begin(), range.first);
  EXPECT_EQ(dict.begin() + 3, range.second);

  range = dict.equal_range("ああ");
  EXPECT_EQ(dict.begin() + 3, range.first);
  EXPECT_EQ(dict.begin() + 4, range.second);

  range = dict.equal_range("This key is not found");
  EXPECT_EQ(dict.end(), range.first);
  EXPECT_EQ(dict.end(), range.second);
}

}  // namespace
}  // namespace mozc
