/* 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 <string>
 #include <vector>
 #include <memory>

 #include <fstream>

 #include <iostream>
 #include <functional>

 #include "token.h"
 #include "user.h"

 #include "base32.h"

 #include "sys_fstream.h"

 #include "random_source.h"

 
 namespace
 {

 class tokens_impl : public tokens_ifc

 {
 private:

     fstreams fstreams_;

     totp_generator generator_;

     random_source rand_;

 public:

     tokens_impl (const fstreams &fstreams, const totp_generator generator,
                  const random_source rand) :

         fstreams_ (fstreams), generator_ (generator), rand_ (rand) {}

     std::string token (const user &user) const override

     {

         // Get key

         std::string line = read_key (user);
 

         if (line == "") {
             return "";
         }
 
         base32 codec;

         std::vector<uint8_t> key = codec.decode (line);

         return generator_.generate_token (key);

     }
 
 private:

     std::string get_key_path (const user &user) const
     {

         return user.home_directory() + "/.dual_control";
     }
 

     bool key_exists (const user &user) const
     {

         // check if file exists

         std::string file_path = get_key_path (user);
         fstreams::pstream stream (fstreams_.open_fstream (file_path));

         return stream->good();
     }
 

     std::string read_key (const user &user) const
     {
         std::string file_path = get_key_path (user);

         fstreams::pstream stream (fstreams_.open_fstream (file_path));

         std::vector<char> line_v (16);
         stream->read (line_v.data(), line_v.size());

         if (stream->fail()) {
             return "";
         }

         std::string line (line_v.begin(), line_v.end());

         return line;
     }
 public:

     std::string generate_key() const override
     {
         base32 codec;
         // get randomness
         int length = 10;

         std::vector<uint8_t> random_bytes (rand_.get_random_bytes (length));

         // base32encode it
         std::string key = codec.encode (random_bytes);
         return key;
     }
 

     std::string ensure_key (const user &user) const override
     {
         if (!key_exists (user)) {

             std::string key = generate_key();

             save (user, key);

             return key;
         } else {

             return read_key (user);

         }

     }

     void save (const user &user, const std::string &key) const override

     {

         std::string file_path = get_key_path (user);

         fstreams::postream stream (fstreams_.open_ofstream (file_path,
                                    std::ios_base::trunc));

         *stream << key<< std::endl;

     }

 };

 }

 tokens tokens::create (const fstreams &fstreams,

                        const totp_generator &generator,
                        const random_source &rand)

 {

     return tokens (tokens::delegate

                    (new tokens_impl (fstreams, generator, rand)));

 }