#ifndef CONNECTION_H
#define CONNECTION_H

#include <QUuid>
#include <QVector>
#include <vector>
#include <string>


enum class SslMode {
	disable=0,
	allow=1,
	prefer=2,
	require=3,
	verify_ca=4,
	verify_full=5
};

enum class PasswordState {
	NotNeeded, ///< the Connection doesn't require a password
	NotStored, ///< password needed but we do not know it
	SavedPasswordManager, ///< Saved in the password manager
};

class QProcessEnvironment;
class QString;

class ConnectionConfig;

/** Base class for ConnectionGroup and ConnectionConfig
 * to enable the use of RTTI in the tree model class.
 */
class ConnectionNode {
public:
	virtual ~ConnectionNode() = default;
};

class ConnectionGroup: public ConnectionNode {
public:
	int conngroup_id;
	QString name;

	using Connections = QVector<std::shared_ptr<ConnectionConfig>>;
	const Connections& connections() const { return m_connections; }

	void erase(int idx, int count = 1);
	/// Adds cc to the group and returns the index within the group.
	int add(std::shared_ptr<ConnectionConfig> cc);
	void update(int idx, const ConnectionConfig &cc);

	bool operator==(const ConnectionGroup &rhs) const {
		return conngroup_id == rhs.conngroup_id
				&& name == rhs.name;
	}
private:
	Connections m_connections;
};

class ConnectionConfig: public ConnectionNode {
public:
	ConnectionConfig(); // Default object containing invalid uuid

	const ConnectionGroup* parent() const;
	void setParent(ConnectionGroup *grp);

	void setUuid(const QUuid &uuid);
	const QUuid &uuid() const;

	void setName(std::string desc);
	const std::string& name() const;

	void setHost(std::string host);
	const std::string& host() const;

	void setHostAddr(std::string v);
	const std::string& hostAddr() const;

	void setPort(unsigned short port);
	unsigned short port() const;

	void setUser(std::string v);
	const std::string& user() const;

	void setPassword(std::string v);
	const std::string& password() const;

	void setDbname(std::string v);
	const std::string& dbname() const;

	void setSslMode(SslMode m);
	SslMode sslMode() const;

	void setSslCert(std::string v);
	const std::string& sslCert() const;

	void setSslKey(std::string v);
	const std::string& sslKey() const;

	void setSslRootCert(std::string v);
	const std::string& sslRootCert() const;

	void setSslCrl(std::string v);
	const std::string& sslCrl() const;

	const char * const * getKeywords() const;
	const char * const * getValues() const;

	PasswordState passwordState() const;
	void setPasswordState(PasswordState password_state);

	bool isSameDatabase(const ConnectionConfig &rhs) const;

	void writeToEnvironment(QProcessEnvironment &env) const;

	bool dirty() const;
	void clean();

	bool operator==(QUuid id) const { return m_uuid == id; }

	QString makeLongDescription() const;
private:
	QUuid m_uuid;
	std::string m_name;
	std::string m_host;
	std::string m_hostaddr;
	std::string m_port = "5432";

	std::string m_user;
	std::string m_password; ///< TODO do we want to keep this here or should we remember it seperatly?
	std::string m_dbname;

	std::string m_sslMode;
	std::string m_sslCert;
	std::string m_sslKey;
	std::string m_sslRootCert;
	std::string m_sslCrl;

	std::string m_applicationName;
	PasswordState m_passwordState = PasswordState::NotStored;

	bool m_dirty = false;
	ConnectionGroup* m_group;


	static void strToEnv(QProcessEnvironment &env, const QString &var, const std::string &val);

	static std::vector<const char*> s_keywords;
	mutable std::vector<const char*> m_values;
};


#endif // CONNECTION_H