#ifndef PASSWORDMANAGER_H
#define PASSWORDMANAGER_H

#include "Expected.h"
#include <botan/secmem.h>
#include <string>
#include <memory>

#include <botan/pwdhash.h>


//#include <botan/botan.h>
//#include <botan/symkey.h>

#include <map>

namespace Botan {

	class Encrypted_PSK_Database_SQL;
	class Sqlite3_Database;
	class PasswordHash;

}

class PasswordManagerException: public std::exception {
public:
	using std::exception::exception; //(char const* const _Message);
};

class PasswordManagerLockedException: public PasswordManagerException {
public:
	using PasswordManagerException::PasswordManagerException;

};

class PasswordManager {
public:
	enum Result {
		Ok,
		Locked,
		Error
	};

	PasswordManager() = default;

	void openDatabase(std::shared_ptr<Botan::Sqlite3_Database> db, std::string passphrase);
	void closeDatabase();

	void set(const std::string &id, const std::string &passwd);
	std::string get(const std::string &id, const std::string &passwd);
	void remove(const std::string &id);
private:
	std::string m_passwordTableName = "psk_passwd";
	std::string m_secretAlgoTableName = "psk_masterkey_algo";
	std::unique_ptr<Botan::Encrypted_PSK_Database_SQL> m_pskDatabase;

	bool isPskStoreInitialized(std::shared_ptr<Botan::Sqlite3_Database> db);
	void initializeNewPskStore(std::shared_ptr<Botan::Sqlite3_Database> db);

	class KeyStrengthener {
	public:
		KeyStrengthener() = default;
		KeyStrengthener(std::unique_ptr<Botan::PasswordHash> hasher, Botan::secure_vector<uint8_t> salt, size_t keysize)
			: m_hasher (std::move(hasher))
			, m_salt   (std::move(salt))
			, m_keySize(keysize)
		{}

		KeyStrengthener(const KeyStrengthener&) = delete;
		KeyStrengthener& operator=(const KeyStrengthener &) = delete;

		KeyStrengthener(KeyStrengthener &&rhs)
			: m_hasher (std::move(rhs.m_hasher))
			, m_salt   (std::move(rhs.m_salt))
			, m_keySize(rhs.m_keySize)
		{}
		KeyStrengthener& operator=(KeyStrengthener &&rhs)
		{
			if (&rhs != this) {
				m_hasher  = std::move(rhs.m_hasher);
				m_salt    = std::move(rhs.m_salt);
				m_keySize = rhs.m_keySize;
			}
			return *this;
		}

		Botan::secure_vector<uint8_t> derive(const std::string &passphrase);
		void saveParams(std::shared_ptr<Botan::Sqlite3_Database> db, const std::string &table_name);
	private:
		std::unique_ptr<Botan::PasswordHash> m_hasher;
		Botan::secure_vector<uint8_t> m_salt;
		size_t m_keySize;
	};

	/// Get PasswordHash from parameters in database
	KeyStrengthener getKeyStrengthener(std::shared_ptr<Botan::Sqlite3_Database> db);
	KeyStrengthener createKeyStrengthener();

};


#endif // PASSWORDMANAGER_H