/* Copyright (C) CJ Affiliate
  *
  * You may use, distribute and modify this code under  the
  * terms of the  GNU General Public License  version 2  or
  * later.
  *
  * You should have received a copy of the license with this
  * file. If not, you will find a copy in the "LICENSE" file
  * at https://github.com/cjdev/dual-control.
  */

 #include <memory>

 #include <algorithm>

 #include <initializer_list>
 #include <vector>

 #include <climits>

 #include <ctime>
 #include <iostream>

 #include "generator.h"

 #include "sys_stdlib.h"

 #include "sys_time.h"

 #include "test_util.h"

 #include "typealiases.h"

 class fake_stdlib : public stdlib_ifc
 {
 
 private:
     std::vector<int> samples_;
     mutable std::vector<int>::iterator current_;
 public:
     fake_stdlib ( const std::initializer_list<int> &samples)
         : samples_ (samples.begin(), samples.end()),
           current_ (samples_.begin()) {}
     int rand() const override
     {
         if (current_ != samples_.end()) {
             auto rval = *current_;
             current_ += 1;
             return rval;
         }
 
         return 0;

     }
 };
 

 class fake_time : public sys_time_ifc
 {
 
 private:
     std::vector<time_t> samples_;
     mutable std::vector<time_t>::iterator current_;
 public:
     fake_time ( const std::initializer_list<time_t> &samples)
         : samples_ (samples.begin(), samples.end()),
           current_ (samples_.begin()) {}
     time_t time (time_t *time_ptr) const override
     {
         if (current_ != samples_.end()) {
             auto rval = *current_;
 
             if (time_ptr != nullptr) {
                 *time_ptr = rval;
             }
 
             current_ += 1;
             return rval;
         }
 
         return 0;
     }
 };
 

 int given_digits()

 {
     // given

     std::initializer_list<time_t> samples { 1 };
     auto test_stdtime = std::make_shared<fake_time> (samples);
 
     sys_time stdtime (test_stdtime);
     // Fake the Key

     auto generator = totp_generator (stdtime, 6);

     // when

     octet_vector key { 0 };

     auto actual = generator.generate_token (key);

     // then
     check (actual.size() == 6, "size is wrong");
     check (std::all_of (actual.begin(), actual.end(), [] (char c) {
         return c >= '0' && c <= '9';
     }), "not just digits");
     succeed();

 }
 

 int modulated_source_modulates_tokens()
 {

     // given

     std::initializer_list<time_t> samples { 1, 31 };
     auto test_stdtime = std::make_shared<fake_time> (samples);
 
     sys_time stdtime (test_stdtime);

     auto generator = totp_generator (stdtime, 6);

 
     // when

     octet_vector key { 0 };

     auto actual1 = generator.generate_token (key);
     auto actual2 = generator.generate_token (key);

 
     // then

     check (actual1 != actual2, "tokens should be different");

     succeed();
 }
 

 int int_max()
 {
     // given

     std::initializer_list<time_t> samples { INT_MAX };
     auto test_stdtime = std::make_shared<fake_time> (samples);
 
     sys_time stdtime (test_stdtime);

     auto generator = totp_generator (stdtime, 6);

     octet_vector key { 0 };

 
     // when

     auto actual = generator.generate_token (key);

 
     // then
     check (actual.size() == 6, "size is wrong");
     check (std::all_of (actual.begin(), actual.end(), [] (char c) {
         return c >= '0' && c <= '9';
     }), "not just digits");
     succeed();
 }
 
 int int_min()
 {
     // given

     std::initializer_list<time_t> samples { INT_MIN };
     auto test_stdtime = std::make_shared<fake_time> (samples);

     octet_vector key { 0 };

 
     sys_time stdtime (test_stdtime);

     auto generator = totp_generator (stdtime, 6);

 
     // when

     auto actual = generator.generate_token (key);

 
     // then
     check (actual.size() == 6, "size is wrong");
     check (std::all_of (actual.begin(), actual.end(), [] (char c) {
         return c >= '0' && c <= '9';
     }), "not just digits");
     succeed();
 }
 

 // totp test
 int int_precomputed()
 {
     // given
     // The token for key 76I6WTYEUTNCJUREMGKVM45PMA and time '2017/01/01 00:00:00' is 258675
     time_t theTime = 1483257600;
     std::initializer_list<time_t> samples { theTime }; //
     auto test_stdtime = std::make_shared<fake_time> (samples);
 
     sys_time stdtime (test_stdtime);
     // Fake the Key

     octet_vector key {255, 145, 235, 79, 4, 164, 218, 36, 210, 36, 97, 149, 86, 115, 175, 96};

     auto generator = totp_generator (stdtime, 6);

     std::string expected = "258675";
 
     // when

     auto actual = generator.generate_token (key);

 
     // then
     check (actual.size() == 6, "size is wrong");

     check (actual == expected, "precomputed value failed to match");

     succeed();
 }
 

 int run_tests()
 {

     test (given_digits);

     test (modulated_source_modulates_tokens);

     test (int_max);
     test (int_min);

     test (int_precomputed);

     succeed();
 }
 

 int main (int argc, char *argv[])
 {

     return !run_tests();
 }