// Copyright 2010-2015, 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 "usage_stats/usage_stats.h"

#include <map>
#include <string>

#include "base/port.h"
#include "base/scoped_ptr.h"
#include "base/system_util.h"
#include "config/stats_config_util.h"
#include "config/stats_config_util_mock.h"
#include "storage/registry.h"
#include "storage/storage_interface.h"
#include "testing/base/public/gunit.h"
#include "usage_stats/usage_stats.pb.h"

DECLARE_string(test_tmpdir);

namespace mozc {
namespace usage_stats {

class UsageStatsTest : public ::testing::Test {
 protected:
  virtual void SetUp() {
    SystemUtil::SetUserProfileDirectory(FLAGS_test_tmpdir);
    EXPECT_TRUE(storage::Registry::Clear());
    mozc::config::StatsConfigUtil::SetHandler(&stats_config_util_);
  }
  virtual void TearDown() {
    mozc::config::StatsConfigUtil::SetHandler(NULL);
    EXPECT_TRUE(storage::Registry::Clear());
  }

 private:
  mozc::config::StatsConfigUtilMock stats_config_util_;
};

TEST_F(UsageStatsTest, IsListedTest) {
  EXPECT_TRUE(UsageStats::IsListed("Commit"));
  EXPECT_FALSE(UsageStats::IsListed("WeDoNotDefinedThisStats"));
}

TEST_F(UsageStatsTest, GetterTest) {
  // Use actual items, but they do not matter with practical usages.
  const char kCountKey[] = "ShutDown";
  const char kIntegerKey[] = "UserRegisteredWord";
  const char kBooleanKey[] = "CuasEnabled";
  const char kTimingKey[] = "ElapsedTimeUSec";
  const char kVirtualKeyboardKey[] = "VirtualKeyboardStats";

  uint32 count_val = 0;
  int32 integer_val = -1;
  bool boolean_val = false;
  uint64 total_time = 0;
  uint32 num_timings = 0;
  uint32 avg_time = 0;
  uint32 min_time = 0;
  uint32 max_time = 0;
  Stats virtual_keyboard_val;
  Stats stats_val;
  // Cannot get values when no values are registered.
  EXPECT_FALSE(UsageStats::GetCountForTest(kCountKey, &count_val));
  EXPECT_FALSE(UsageStats::GetIntegerForTest(kIntegerKey, &integer_val));
  EXPECT_FALSE(UsageStats::GetBooleanForTest(kBooleanKey, &boolean_val));
  EXPECT_FALSE(UsageStats::GetTimingForTest(kTimingKey, &total_time,
                   &num_timings, &avg_time, &min_time, &max_time));
  EXPECT_FALSE(UsageStats::GetVirtualKeyboardForTest(kVirtualKeyboardKey,
                                                     &virtual_keyboard_val));
  EXPECT_FALSE(UsageStats::GetStatsForTest(kCountKey, &stats_val));

  // Update stats.
  UsageStats::IncrementCount(kCountKey);
  UsageStats::SetInteger(kIntegerKey, 10);
  UsageStats::SetBoolean(kBooleanKey, true);
  UsageStats::UpdateTiming(kTimingKey, 5);
  UsageStats::UpdateTiming(kTimingKey, 7);
  map<string, TouchEventStatsMap> inserted_virtual_keyboard_val;
  inserted_virtual_keyboard_val["test1"] = TouchEventStatsMap();
  UsageStats::StoreTouchEventStats(kVirtualKeyboardKey,
                                   inserted_virtual_keyboard_val);

  // Cannot get with wrong types.
  EXPECT_FALSE(UsageStats::GetCountForTest(kIntegerKey, &count_val));
  EXPECT_FALSE(UsageStats::GetIntegerForTest(kBooleanKey, &integer_val));
  EXPECT_FALSE(UsageStats::GetBooleanForTest(kTimingKey, &boolean_val));
  EXPECT_FALSE(UsageStats::GetTimingForTest(kVirtualKeyboardKey, NULL, NULL,
                                            NULL, NULL, NULL));
  EXPECT_FALSE(UsageStats::GetVirtualKeyboardForTest(kCountKey,
                                                     &virtual_keyboard_val));

  // Check values.
  EXPECT_TRUE(UsageStats::GetCountForTest(kCountKey, &count_val));
  EXPECT_TRUE(UsageStats::GetIntegerForTest(kIntegerKey, &integer_val));
  EXPECT_TRUE(UsageStats::GetBooleanForTest(kBooleanKey, &boolean_val));
  EXPECT_TRUE(UsageStats::GetTimingForTest(kTimingKey, &total_time,
                                           NULL, NULL, NULL, NULL));
  EXPECT_TRUE(UsageStats::GetTimingForTest(kTimingKey, NULL, &num_timings,
                                           NULL, NULL, NULL));
  EXPECT_TRUE(UsageStats::GetTimingForTest(kTimingKey, NULL, NULL, &avg_time,
                                           NULL, NULL));
  EXPECT_TRUE(UsageStats::GetTimingForTest(kTimingKey, NULL, NULL, NULL,
                                           &min_time, NULL));
  EXPECT_TRUE(UsageStats::GetTimingForTest(kTimingKey, NULL, NULL, NULL,
                                           NULL, &max_time));
  EXPECT_TRUE(UsageStats::GetStatsForTest(kCountKey, &stats_val));
  EXPECT_TRUE(UsageStats::GetVirtualKeyboardForTest(kVirtualKeyboardKey,
                                                    &virtual_keyboard_val));
  EXPECT_EQ(1, count_val);
  EXPECT_EQ(10, integer_val);
  EXPECT_TRUE(boolean_val);
  EXPECT_EQ(12, total_time);
  EXPECT_EQ(2, num_timings);
  EXPECT_EQ(6, avg_time);
  EXPECT_EQ(5, min_time);
  EXPECT_EQ(7, max_time);
  EXPECT_EQ(Stats::COUNT, stats_val.type());
  EXPECT_EQ(1, virtual_keyboard_val.virtual_keyboard_stats_size());
  EXPECT_EQ(1, stats_val.count());

  // Update stats.
  UsageStats::IncrementCount(kCountKey);
  UsageStats::SetInteger(kIntegerKey, 15);
  UsageStats::SetBoolean(kBooleanKey, false);
  UsageStats::UpdateTiming(kTimingKey, 9);
  inserted_virtual_keyboard_val.clear();
  inserted_virtual_keyboard_val["test2"] = TouchEventStatsMap();
  UsageStats::StoreTouchEventStats(kVirtualKeyboardKey,
                                   inserted_virtual_keyboard_val);

  // Check updated values.
  EXPECT_TRUE(UsageStats::GetCountForTest(kCountKey, &count_val));
  EXPECT_TRUE(UsageStats::GetIntegerForTest(kIntegerKey, &integer_val));
  EXPECT_TRUE(UsageStats::GetBooleanForTest(kBooleanKey, &boolean_val));
  EXPECT_TRUE(UsageStats::GetTimingForTest(kTimingKey, &total_time,
                                           &num_timings, &avg_time, &min_time,
                                           &max_time));
  EXPECT_TRUE(UsageStats::GetStatsForTest(kCountKey, &stats_val));
  EXPECT_TRUE(UsageStats::GetVirtualKeyboardForTest(kVirtualKeyboardKey,
                                                    &virtual_keyboard_val));
  EXPECT_EQ(2, count_val);
  EXPECT_EQ(15, integer_val);
  EXPECT_FALSE(boolean_val);
  EXPECT_EQ(21, total_time);
  EXPECT_EQ(3, num_timings);
  EXPECT_EQ(7, avg_time);
  EXPECT_EQ(5, min_time);
  EXPECT_EQ(9, max_time);
  EXPECT_EQ(Stats::COUNT, stats_val.type());
  EXPECT_EQ(2, virtual_keyboard_val.virtual_keyboard_stats_size());
  EXPECT_EQ(2, stats_val.count());
}

namespace {
void SetDoubleValueStats(
    uint32 num, double total, double square_total,
    usage_stats::Stats::DoubleValueStats *double_stats) {
  double_stats->set_num(num);
  double_stats->set_total(total);
  double_stats->set_square_total(square_total);
}

void SetEventStats(
    uint32 source_id,
    uint32 sx_num, double sx_total, double sx_square_total,
    uint32 sy_num, double sy_total, double sy_square_total,
    uint32 dx_num, double dx_total, double dx_square_total,
    uint32 dy_num, double dy_total, double dy_square_total,
    uint32 tl_num, double tl_total, double tl_square_total,
    usage_stats::Stats::TouchEventStats *event_stats) {
  event_stats->set_source_id(source_id);
  SetDoubleValueStats(sx_num, sx_total, sx_square_total,
                      event_stats->mutable_start_x_stats());
  SetDoubleValueStats(sy_num, sy_total, sy_square_total,
                      event_stats->mutable_start_y_stats());
  SetDoubleValueStats(dx_num, dx_total, dx_square_total,
                      event_stats->mutable_direction_x_stats());
  SetDoubleValueStats(dy_num, dy_total, dy_square_total,
                      event_stats->mutable_direction_y_stats());
  SetDoubleValueStats(tl_num, tl_total, tl_square_total,
                      event_stats->mutable_time_length_stats());
}
}  // namespace

TEST_F(UsageStatsTest, StoreTouchEventStats) {
  string stats_str;
  EXPECT_FALSE(storage::Registry::Lookup("usage_stats.VirtualKeyboardStats",
                                         &stats_str));
  EXPECT_FALSE(storage::Registry::Lookup("usage_stats.VirtualKeyboardMissStats",
                                         &stats_str));
  map<string, map<uint32, Stats::TouchEventStats> > touch_stats;

  Stats::TouchEventStats &event_stats1 = touch_stats["KEYBOARD_01"][10];
  SetEventStats(10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
                14, 15, 16, &event_stats1);

  Stats::TouchEventStats &event_stats2 = touch_stats["KEYBOARD_01"][20];
  SetEventStats(20, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
                114, 115, 116, &event_stats2);

  Stats::TouchEventStats &event_stats3 = touch_stats["KEYBOARD_02"][10];
  SetEventStats(10, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
                214, 215, 216, &event_stats3);

  UsageStats::StoreTouchEventStats("VirtualKeyboardStats", touch_stats);

  EXPECT_TRUE(storage::Registry::Lookup("usage_stats.VirtualKeyboardStats",
                                         &stats_str));

  Stats stats;
  EXPECT_TRUE(stats.ParseFromString(stats_str));
  EXPECT_EQ(Stats::VIRTUAL_KEYBOARD, stats.type());
  EXPECT_EQ(2, stats.virtual_keyboard_stats_size());
  EXPECT_EQ("KEYBOARD_01",
      stats.virtual_keyboard_stats(0).keyboard_name());
  EXPECT_EQ("KEYBOARD_02",
      stats.virtual_keyboard_stats(1).keyboard_name());
  EXPECT_EQ(2, stats.virtual_keyboard_stats(0).touch_event_stats_size());
  EXPECT_EQ(1, stats.virtual_keyboard_stats(1).touch_event_stats_size());

  EXPECT_EQ(event_stats1.DebugString(),
      stats.virtual_keyboard_stats(0).touch_event_stats(0).DebugString());
  EXPECT_EQ(event_stats2.DebugString(),
      stats.virtual_keyboard_stats(0).touch_event_stats(1).DebugString());
  EXPECT_EQ(event_stats3.DebugString(),
      stats.virtual_keyboard_stats(1).touch_event_stats(0).DebugString());


  map<string, map<uint32, Stats::TouchEventStats> > touch_stats2;
  Stats::TouchEventStats &event_stats4 = touch_stats2["KEYBOARD_01"][20];
  SetEventStats(20, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313,
                314, 315, 316, &event_stats4);
  Stats::TouchEventStats &event_stats5 = touch_stats2["KEYBOARD_02"][20];
  SetEventStats(20, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413,
                414, 415, 416, &event_stats5);

  UsageStats::StoreTouchEventStats("VirtualKeyboardStats", touch_stats2);

  EXPECT_TRUE(storage::Registry::Lookup("usage_stats.VirtualKeyboardStats",
                                         &stats_str));

  Stats stats2;
  EXPECT_TRUE(stats2.ParseFromString(stats_str));
  EXPECT_EQ(Stats::VIRTUAL_KEYBOARD, stats2.type());
  EXPECT_EQ(2, stats2.virtual_keyboard_stats_size());
  EXPECT_EQ("KEYBOARD_01",
      stats2.virtual_keyboard_stats(0).keyboard_name());
  EXPECT_EQ("KEYBOARD_02",
      stats2.virtual_keyboard_stats(1).keyboard_name());
  EXPECT_EQ(2, stats2.virtual_keyboard_stats(0).touch_event_stats_size());
  EXPECT_EQ(2, stats2.virtual_keyboard_stats(1).touch_event_stats_size());

  Stats::TouchEventStats event_stats6;
  SetEventStats(20, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426,
                428, 430, 432, &event_stats6);

  EXPECT_EQ(event_stats1.DebugString(),
      stats2.virtual_keyboard_stats(0).touch_event_stats(0).DebugString());
  EXPECT_EQ(event_stats6.DebugString(),
      stats2.virtual_keyboard_stats(0).touch_event_stats(1).DebugString());
  EXPECT_EQ(event_stats3.DebugString(),
      stats2.virtual_keyboard_stats(1).touch_event_stats(0).DebugString());
  EXPECT_EQ(event_stats5.DebugString(),
      stats2.virtual_keyboard_stats(1).touch_event_stats(1).DebugString());

  EXPECT_FALSE(storage::Registry::Lookup("usage_stats.VirtualKeyboardMissStats",
                                         &stats_str));
}

}  // namespace usage_stats
}  // namespace mozc