/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
 * Copyright (c) 2014-2015,  Regents of the University of California
 *
 * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
 * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
 *
 * ndn-group-encrypt is free software: you can redistribute it and/or modify it under the terms
 * of the GNU General Public License as published by the Free Software Foundation,
 * either version 3 of the License, or (at your option) any later version.
 *
 * ndn-group-encrypt is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * ndn-group-encrypt, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
 *
 * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
 */

#include "group-manager-db.hpp"
#include "boost-test.hpp"

#include <boost/filesystem.hpp>

namespace ndn {
namespace gep {
namespace tests {

const uint8_t DATA[] = {
0x06, 0xfd, 0x02, 0xd7, 0x07, 0x38, 0x08, 0x03, 0x6e, 0x64, 0x6e, 0x08, 0x03, 0x4b, 0x45,
0x59, 0x08, 0x05, 0x73, 0x69, 0x74, 0x65, 0x31, 0x08, 0x11, 0x6b, 0x73, 0x6b, 0x2d, 0x31,
0x34, 0x31, 0x36, 0x34, 0x32, 0x35, 0x33, 0x37, 0x37, 0x30, 0x39, 0x34, 0x08, 0x07, 0x49,
0x44, 0x2d, 0x43, 0x45, 0x52, 0x54, 0x08, 0x09, 0xfd, 0x00, 0x00, 0x01, 0x49, 0xc9, 0x8b,
0x2e, 0x73, 0x14, 0x03, 0x18, 0x01, 0x02, 0x15, 0xfd, 0x01, 0x61, 0x30, 0x82, 0x01, 0x5d,
0x30, 0x22, 0x18, 0x0f, 0x32, 0x30, 0x31, 0x34, 0x31, 0x31, 0x31, 0x39, 0x31, 0x39, 0x33,
0x33, 0x30, 0x32, 0x5a, 0x18, 0x0f, 0x32, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x39, 0x31,
0x39, 0x33, 0x33, 0x30, 0x32, 0x5a, 0x30, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x29,
0x13, 0x0a, 0x2f, 0x6e, 0x64, 0x6e, 0x2f, 0x73, 0x69, 0x74, 0x65, 0x31, 0x30, 0x82, 0x01,
0x20, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05,
0x00, 0x03, 0x82, 0x01, 0x0d, 0x00, 0x30, 0x82, 0x01, 0x08, 0x02, 0x82, 0x01, 0x01, 0x00,
0xb6, 0x54, 0x7e, 0xe8, 0xf2, 0x91, 0x7d, 0xc1, 0x6d, 0xcb, 0x25, 0x44, 0x97, 0x90, 0xdc,
0x78, 0x15, 0x0e, 0xef, 0xb5, 0xe7, 0xfd, 0x09, 0x2c, 0xf8, 0xd5, 0x9c, 0x2f, 0xe5, 0xa6,
0xae, 0x9d, 0x7e, 0x95, 0x2d, 0xfc, 0xc7, 0xc3, 0x43, 0x46, 0xb0, 0x6f, 0x53, 0xcd, 0xcd,
0x6a, 0x29, 0x1d, 0x95, 0xa1, 0x62, 0xcd, 0xa9, 0xf2, 0xf8, 0xe2, 0xfa, 0x8b, 0x5d, 0xfe,
0xa1, 0x2b, 0x15, 0x3f, 0x7f, 0x71, 0xe6, 0x3e, 0xb9, 0xb1, 0x29, 0xd1, 0x22, 0x6f, 0x56,
0xdf, 0xb6, 0x85, 0xaf, 0xd4, 0xb3, 0x67, 0x8b, 0x94, 0xb8, 0x83, 0xcb, 0x72, 0x86, 0xc4,
0xf2, 0x86, 0xb2, 0x7c, 0x94, 0xbc, 0x38, 0x7b, 0x8c, 0x92, 0x86, 0x36, 0x83, 0x0e, 0x11,
0x8c, 0x95, 0x49, 0xff, 0xcc, 0x16, 0x62, 0xdb, 0x55, 0x40, 0x7f, 0xc8, 0x8d, 0xe4, 0x3f,
0x87, 0x02, 0x87, 0xaf, 0xf6, 0x2f, 0x8a, 0x7d, 0x74, 0x10, 0xd3, 0xbb, 0xa3, 0xfe, 0x5a,
0x7b, 0x8f, 0x56, 0x09, 0x8b, 0x49, 0x46, 0x9f, 0x7d, 0x55, 0xa3, 0x4a, 0xe8, 0x22, 0x7b,
0x80, 0x8a, 0x6f, 0xde, 0x9f, 0xfb, 0x2f, 0xeb, 0xf7, 0x29, 0x8a, 0x38, 0x67, 0x41, 0xae,
0x21, 0x7a, 0xe3, 0x7b, 0x96, 0x1a, 0x90, 0x35, 0x7d, 0x04, 0xaa, 0x4d, 0x9f, 0xe6, 0xd6,
0x00, 0x17, 0x4e, 0x02, 0x34, 0x6c, 0x56, 0x3a, 0x81, 0x3c, 0xb4, 0x7f, 0x98, 0x48, 0x22,
0xa0, 0x9f, 0x53, 0x35, 0xf9, 0x4e, 0xae, 0x8f, 0xc3, 0xfa, 0x0b, 0x93, 0xd4, 0x55, 0x78,
0x05, 0xb0, 0x40, 0x44, 0x48, 0x74, 0xb7, 0x9b, 0x2d, 0x65, 0xf0, 0x3d, 0x2e, 0x87, 0x2b,
0x48, 0x29, 0x12, 0x85, 0xf0, 0xaf, 0xc4, 0xdc, 0x73, 0xce, 0x18, 0x8b, 0xd9, 0x4c, 0x60,
0x15, 0x51, 0xae, 0x47, 0x1e, 0x2b, 0x54, 0xde, 0xf6, 0xba, 0x77, 0x30, 0x5d, 0x68, 0x9a,
0xfb, 0x02, 0x01, 0x11, 0x16, 0x2d, 0x1b, 0x01, 0x01, 0x1c, 0x28, 0x07, 0x26, 0x08, 0x03,
0x6e, 0x64, 0x6e, 0x08, 0x03, 0x4b, 0x45, 0x59, 0x08, 0x11, 0x6b, 0x73, 0x6b, 0x2d, 0x31,
0x34, 0x31, 0x36, 0x34, 0x32, 0x35, 0x32, 0x39, 0x35, 0x35, 0x34, 0x36, 0x08, 0x07, 0x49,
0x44, 0x2d, 0x43, 0x45, 0x52, 0x54, 0x17, 0xfd, 0x01, 0x00, 0x26, 0x40, 0xbc, 0xf0, 0x28,
0x12, 0x69, 0x94, 0x11, 0x13, 0xff, 0x47, 0x2c, 0x6b, 0x12, 0xdd, 0xfa, 0x60, 0x92, 0xe9,
0x59, 0x10, 0x98, 0xd8, 0x11, 0x2a, 0xf0, 0x25, 0xb0, 0x03, 0xb2, 0xda, 0xd3, 0xb6, 0xa9,
0xfb, 0x8b, 0xc3, 0x6f, 0xfb, 0xb4, 0x93, 0x9b, 0x24, 0x9f, 0x7e, 0x63, 0x8a, 0x37, 0xea,
0x88, 0x74, 0xac, 0x0c, 0x04, 0x5b, 0xa2, 0x39, 0x0c, 0xa1, 0x9e, 0x0e, 0xa2, 0xd6, 0x74,
0xca, 0xc4, 0x92, 0x64, 0x9f, 0xc2, 0x68, 0x56, 0xef, 0xc5, 0x11, 0xe8, 0x7a, 0xf3, 0x21,
0xde, 0x88, 0x40, 0x70, 0x2b, 0x44, 0xe0, 0xcb, 0x3b, 0x33, 0xc6, 0x53, 0x65, 0x70, 0x56,
0x08, 0xe2, 0x22, 0x70, 0x9e, 0xe0, 0x38, 0x18, 0xa8, 0x7c, 0x7d, 0x09, 0x15, 0xac, 0xf1,
0x44, 0x63, 0x5d, 0xd5, 0x59, 0xf4, 0xeb, 0x60, 0x6c, 0x6e, 0x77, 0x36, 0x20, 0x2a, 0xe2,
0xd1, 0x2d, 0xa1, 0x7d, 0xd4, 0x6d, 0x29, 0x2d, 0x88, 0xde, 0x9e, 0xf8, 0x64, 0x41, 0x6a,
0xeb, 0x9f, 0x3b, 0x52, 0x06, 0xb1, 0x94, 0x09, 0x3b, 0xc9, 0xba, 0xa0, 0x05, 0x31, 0x2d,
0x49, 0x17, 0x5b, 0xc1, 0x62, 0xf5, 0x19, 0xce, 0x27, 0x7b, 0xe8, 0x4b, 0xeb, 0x80, 0x36,
0xf3, 0xd7, 0xe9, 0x59, 0x22, 0x50, 0x5a, 0x14, 0xb0, 0x1a, 0xa5, 0x6b, 0x33, 0xb2, 0x83,
0x72, 0x11, 0xf4, 0xd5, 0xd2, 0x32, 0x93, 0x94, 0xb6, 0x8d, 0xed, 0xcd, 0xce, 0x54, 0x79,
0xe8, 0xc3, 0x3c, 0xa8, 0xc6, 0x71, 0xa7, 0x61, 0xba, 0x70, 0x44, 0x94, 0xc9, 0xfc, 0xd0,
0x20, 0x00, 0x87, 0xdc, 0xf3, 0x3c, 0x47, 0x1b, 0x4f, 0x91, 0x4c, 0xc7, 0x49, 0xb7, 0xe4,
0xe3, 0x84, 0xb7, 0x82, 0x52, 0xec, 0x91, 0xa9, 0x28, 0x38, 0x2d, 0x48, 0x89, 0xc7, 0xcf,
0xfa, 0x63, 0x0b, 0xf0, 0x62, 0x51, 0xac, 0xe9, 0xdb, 0xfd, 0x1c
};

const uint8_t SCHEDULE[] = {
  0x8f, 0xc4,// Schedule
  0x8d, 0x90,// WhiteIntervalList
  0x8c, 0x2e, // RepetitiveInterval
    0x86, 0x0f,
      0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x35, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x87, 0x0f,
      0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x38, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x88, 0x01,
      0x05,
    0x89, 0x01,
      0x0a,
    0x8a, 0x01,
      0x02,
    0x8b, 0x01,
      0x01,
  0x8c, 0x2e, // RepetitiveInterval
    0x86, 0x0f,
      0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x35, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x87, 0x0f,
      0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x38, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x88, 0x01,
      0x06,
    0x89, 0x01,
      0x08,
    0x8a, 0x01,
      0x01,
    0x8b, 0x01,
      0x01,
  0x8c, 0x2e, // RepetitiveInterval
    0x86, 0x0f,
      0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x35, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x87, 0x0f,
      0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x35, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x88, 0x01,
      0x04,
    0x89, 0x01,
      0x07,
    0x8a, 0x01,
      0x00,
    0x8b, 0x01,
      0x00,
  0x8e, 0x30, // BlackIntervalList
  0x8c, 0x2e, // RepetitiveInterval
     0x86, 0x0f,
      0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x37, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x87, 0x0f,
      0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x37, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x88, 0x01,
      0x07,
    0x89, 0x01,
      0x08,
    0x8a, 0x01,
      0x00,
    0x8b, 0x01,
      0x00
};

const uint8_t REPETITIVE_INTERVAL[] = {
  0x8c, 0x2e, // RepetitiveInterval
    0x86, 0x0f,
      0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x35, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x87, 0x0f,
      0x32, 0x30, 0x31, 0x35, 0x30, 0x39, 0x32, 0x31, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
    0x88, 0x01,
      0x02,
    0x89, 0x01,
      0x0a,
    0x8a, 0x01,
      0x05,
    0x8b, 0x01,
      0x01
};

class GroupManagerDBFixture
{
public:
  GroupManagerDBFixture()
    : tmpPath(boost::filesystem::path(TMP_TESTS_PATH))
  {
    boost::filesystem::create_directories(tmpPath);
  }

  ~GroupManagerDBFixture()
  {
    boost::filesystem::remove_all(tmpPath);
  }

public:
  boost::filesystem::path tmpPath;
};

BOOST_FIXTURE_TEST_SUITE(TestGroupManagerDB, GroupManagerDBFixture)

BOOST_AUTO_TEST_CASE(DatabaseFunctions)
{
  // construction
  std::string dbDir = tmpPath.c_str();
  dbDir += "/test.db";
  GroupManagerDB db(dbDir);

  Block dataBlock(DATA, sizeof(DATA));
  Block scheduleBlock(SCHEDULE, sizeof(SCHEDULE));

  // create schedule
  Schedule schedule(scheduleBlock);

  // create member
  Data data1(dataBlock);
  data1.setName(Name("/ndn/BoyA/KEY/ksk-123/ID-CERT/123"));
  Data data2(dataBlock);
  data2.setName(Name("/ndn/BoyB/KEY/ksk-123/ID-CERT/123"));
  Data data3(dataBlock);
  data3.setName(Name("/ndn/GirlC/KEY/ksk-123/ID-CERT/123"));
  Data data4(dataBlock);
  data4.setName(Name("/ndn/GirlD/KEY/ksk-123/ID-CERT/123"));
  Data data5(dataBlock);
  data5.setName(Name("/ndn/Hello/KEY/ksk-123/ID-CERT/123"));

  // add schedules into the database
  BOOST_CHECK_NO_THROW(db.addSchedule("work-time", schedule));
  BOOST_CHECK_NO_THROW(db.addSchedule("rest-time", schedule));
  BOOST_CHECK_NO_THROW(db.addSchedule("play-time", schedule));
  BOOST_CHECK_NO_THROW(db.addSchedule("boelter-time", schedule));

  // throw exception when adding a schedule called an existing name
  BOOST_CHECK_THROW(db.addSchedule("boelter-time", schedule), GroupManagerDB::Error);

  // add members into the database
  BOOST_CHECK_NO_THROW(db.addMember("work-time", data1));
  BOOST_CHECK_NO_THROW(db.addMember("rest-time", data2));
  BOOST_CHECK_NO_THROW(db.addMember("play-time", data3));
  BOOST_CHECK_NO_THROW(db.addMember("play-time", data4));

  // throw exception when adding a member having a not existing schedule name
  BOOST_CHECK_THROW(db.addMember("false-time", data5), GroupManagerDB::Error);

  BOOST_CHECK_NO_THROW(db.addMember("boelter-time", data5));

  // throw exception when adding a member having an existing identity
  BOOST_CHECK_THROW(db.addMember("work-time", data5), GroupManagerDB::Error);

  // has function
  BOOST_CHECK_EQUAL(db.hasSchedule("work-time"), true);
  BOOST_CHECK_EQUAL(db.hasSchedule("rest-time"), true);
  BOOST_CHECK_EQUAL(db.hasSchedule("play-time"), true);
  BOOST_CHECK_EQUAL(db.hasSchedule("sleep-time"), false);
  BOOST_CHECK_EQUAL(db.hasSchedule(""), false);

  BOOST_CHECK_EQUAL(db.hasMember(Name("/ndn/BoyA")), true);
  BOOST_CHECK_EQUAL(db.hasMember(Name("/ndn/BoyB")), true);
  BOOST_CHECK_EQUAL(db.hasMember(Name("/ndn/BoyC")), false);

  // get schedule
  Schedule scheduleResult = db.getSchedule("work-time");
  BOOST_CHECK(scheduleResult.wireEncode() == scheduleBlock);

  scheduleResult = db.getSchedule("play-time");
  BOOST_CHECK(scheduleResult.wireEncode() == scheduleBlock);

  // throw exception when there is no such schedule in database
  BOOST_CHECK_THROW(db.getSchedule("work-time-11"), GroupManagerDB::Error);

  // get certificate of a member
  Data dataResult = db.getMemberCert(Name("/ndn/BoyA"));
  BOOST_CHECK(dataResult.wireEncode() == data1.wireEncode());

  dataResult = db.getMemberCert(Name("/ndn/GirlC"));
  BOOST_CHECK(dataResult.wireEncode() == data3.wireEncode());

  // throw error when there is no such member in database
  BOOST_CHECK_THROW(db.getMemberCert(Name("/ndn/GirlA")), GroupManagerDB::Error);

  // list all schedule names
  std::list<std::string> names = db.listAllScheduleNames();
  BOOST_CHECK(std::find(names.begin(), names.end(), "work-time") != names.end());
  BOOST_CHECK(std::find(names.begin(), names.end(), "play-time") != names.end());
  BOOST_CHECK(std::find(names.begin(), names.end(), "rest-time") != names.end());
  BOOST_CHECK(std::find(names.begin(), names.end(), "sleep-time") == names.end());

  // list members of a schedule
  std::map<Name, Data> memberMap = db.getScheduleMembers("play-time");
  BOOST_CHECK(memberMap.size() != 0);

  // when there's no such schedule, the return list's size is 0
  BOOST_CHECK_EQUAL(db.getScheduleMembers("sleep-time").size(), 0);

  // list all members
  std::list<Name> members = db.listAllMembers();
  BOOST_CHECK(std::find(members.begin(), members.end(), Name("/ndn/GirlC")) != members.end());
  BOOST_CHECK(std::find(members.begin(), members.end(), Name("/ndn/GirlD")) != members.end());
  BOOST_CHECK(std::find(members.begin(), members.end(), Name("/ndn/BoyA")) != members.end());
  BOOST_CHECK(std::find(members.begin(), members.end(), Name("/ndn/BoyB")) != members.end());

  // rename schedule
  BOOST_CHECK_EQUAL(db.hasSchedule("boelter-time"), true);
  db.renameSchedule("boelter-time", "rieber-time");
  BOOST_CHECK_EQUAL(db.hasSchedule("boelter-time"), false);
  BOOST_CHECK_EQUAL(db.hasSchedule("rieber-time"), true);
  BOOST_CHECK_EQUAL(db.getMemberSchedule("/ndn/Hello"), "rieber-time");

  // update schedule
  Schedule newSchedule(scheduleBlock);
  Block repIntervalBlock(REPETITIVE_INTERVAL, sizeof(REPETITIVE_INTERVAL));
  newSchedule.addWhiteInterval(RepetitiveInterval(repIntervalBlock));
  db.updateSchedule("rieber-time", newSchedule);
  scheduleResult = db.getSchedule("rieber-time");
  BOOST_CHECK(scheduleResult.wireEncode() != scheduleBlock);
  BOOST_CHECK(scheduleResult.wireEncode() == newSchedule.wireEncode());

  // add a new schedule when update a not existing schedule
  BOOST_CHECK_EQUAL(db.hasSchedule("ralphs-time"), false);
  db.updateSchedule("ralphs-time", newSchedule);
  BOOST_CHECK_EQUAL(db.hasSchedule("ralphs-time"), true);

  // update schedule of member
  db.updateMemberSchedule(Name("/ndn/Hello"), "play-time");
  BOOST_CHECK_EQUAL(db.getMemberSchedule(Name("/ndn/Hello")), "play-time");

  // delete member
  BOOST_CHECK_EQUAL(db.hasMember(Name("/ndn/Hello")), true);
  db.deleteMember(Name("/ndn/Hello"));
  BOOST_CHECK_EQUAL(db.hasMember(Name("/ndn/Hello")), false);

  // delete a not existing member
  BOOST_CHECK_NO_THROW(db.deleteMember(Name("/ndn/notExisting")));

  // delete the schedule and all the members using this schedule should be deleted
  db.deleteSchedule("play-time");
  BOOST_CHECK_EQUAL(db.hasSchedule("play-time"), false);
  BOOST_CHECK_EQUAL(db.hasMember(Name("/ndn/GirlC")), false);
  BOOST_CHECK_EQUAL(db.hasMember(Name("/ndn/GirlD")), false);

  // delete a not existing schedule
  BOOST_CHECK_NO_THROW(db.deleteSchedule("not-existing-time"));
}

BOOST_AUTO_TEST_SUITE_END()

} // namespace tests
} // namespace gep
} // namespace ndn