#ifndef MYX_REDIS_CLIENT_HPP_
#define MYX_REDIS_CLIENT_HPP_

#pragma once

#include <myx/redis/base.hpp>

#include <QVariant>
#include <QJsonArray>
#include <QJsonObject>
#include <unordered_set>

// QT_FORWARD_DECLARE_CLASS( QTcpSocket )

namespace myx {

namespace redis {

/*!
 * \brief Реализует клиентскую часть в соответствии с RESP
 */
class Client : public Base
{
	Q_OBJECT
public:
	Client( int database = 0, QObject* parent = nullptr );
	virtual ~Client();
	int database() const;
	int exists( const QStringList& keys );
	void select( int database );
	bool flushdb();
	bool del( const QStringList& keys );
	bool expire( const QString& key, int secs );
	bool pexpire( const QString& key, int msecs );
	bool persist( const QString& key );
	bool publish( const QString& channel, const QByteArray& message );
	static bool publish( const QString& channel, const QByteArray& message,
	                     const QString& host, quint16 port = 6379 );
	bool set( const QString& key, const QVariant& value );
	static bool set( const QString& key, const QVariant& value,
	                 int database, const QString& host = "127.0.0.1", quint16 port = 6379 );
	QByteArray scriptLoad( const QByteArray& script );
	QByteArray get( const QString& key );
	template< typename T >
	T get( const QString& key );
	static QByteArray get( const QString& key, int database,
	                       const QString& host = "127.0.0.1", quint16 port = 6379 );
	template< typename T >
	static T get( const QString& key, int database,
	              const QString& host = "127.0.0.1", quint16 port = 6379 );
	bool hdel( const QString& redisKey, const QStringList& hashKeys );
	bool hset( const QString& key, const QString& field, const QVariant& value );
	bool hmset( const QString& key, const QVariantHash& hash );
	static bool hmset( const QString& key, const QVariantHash& hash, int database,
	                   const QString& host = "127.0.0.1", quint16 port = 6379 );
	QVariantHash hgetall( const QString& key );
	static QVariantHash hgetall( const QString& key, int database,
	                             const QString& host = "127.0.0.1", quint16 port = 6379 );
	QByteArray hget( const QString& redisKey, const QString& hashKey );
	static QByteArray hget( const QString& redisKey, const QString& hashKey,
	                        int database, const QString& host = "127.0.0.1", quint16 port = 6379 );
	bool rpush( const QString& key, const QVariantList& values );
	bool lpush( const QString& key, const QVariantList& values );
	bool lset( const QString& key, int index, const QVariant& value );
	bool lrem( const QString& key, const QVariant& value, int count = 1 );
	bool ltrim( const QString& key, int from, int to );
	int llen( const QString& key );
	QVariantList lrange( const QString& key, int from, int to );
	template< typename T >
	std::vector< T > lrange( const QString& key );
	static QByteArrayList lrange( const QString& key, int from, int to, int database,
	                              const QString& host = "127.0.0.1", quint16 port = 6379 );
	template< typename T >
	static std::vector< T > lrange( const QString& key, int from, int to, int database,
	                                const QString& host = "127.0.0.1", quint16 port = 6379 );
	bool sadd( const QString& key, const QVariantList& values );
	bool srem( const QString& key, const QVariantList& values );
	bool sismember( const QString& key, const QVariant& value );
	static bool sismember( const QString& key, const QVariant& value, int database,
	                       const QString& host = "127.0.0.1", quint16 port = 6379 );
	int scard( const QString& key );
	QVariantList smembers( const QString& key );
	template< typename T >
	std::vector< T > smembers( const QString& key );
	QByteArray rpop( const QString& key );
	QByteArray lindex( const QString& key, int index );
	QStringList keys( const QString& pattern = {} );
	static QStringList keys( const QString& pattern, int database,
	                         const QString& host, quint16 port = 6379 );
	template< typename T >
	T evalSha( const QByteArray& sha, const QVariantList& keys, const QVariantList& argv );
	template< typename T >
	static T evalSha( const QByteArray& sha, const QVariantList& keys, const QVariantList& argv,
	                  int database, const QString& host, quint16 port = 6379 );
	QByteArrayList evalSha( const QByteArray& sha, const QVariantList& keys,
	                        const QVariantList& argv );
	static QByteArrayList evalSha( const QByteArray& sha, const QVariantList& keys,
	                               const QVariantList& argv,
	                               int database, const QString& host, quint16 port = 6379 );

private:
	/*!
	 * \brief Класс для синхронизации порядка чтения/записи в poolSocket;
	 */
	struct Session
	{
		Session( uint& count );
		~Session();

private:
		uint& _count; //!< Счетчик открытых сессий
	};

	int                        _database;           //!< Номер БД в redis
	uint                       _sessionCount { 0 }; //!< Счетчик открытых сессий
	std::vector< QTcpSocket* > _session;            //!< Сокеты для синхронных сессий чтения/записи
	/*!
	 * \brief Содержит TCP соединения, связанные с БД, отличной от текущей
	 */
	std::unordered_set< QTcpSocket* > _outOfDatabase;

	static bool setupSocket( QTcpSocket* socket, int database, const QString& host, quint16 port );
	static bool select( QTcpSocket* socket, int database );
	QTcpSocket* session( int timeout );
}; // class Client

template<>
QVariant Client::evalSha< QVariant >( const QByteArray& sha, const QVariantList& keys,
                                      const QVariantList& argv );
template<>
QVariantList Client::evalSha< QVariantList >( const QByteArray& sha, const QVariantList& keys,
                                              const QVariantList& argv );
template<>
QVariantHash Client::evalSha< QVariantHash >( const QByteArray& sha, const QVariantList& keys,
                                              const QVariantList& argv );
template<>
QJsonArray Client::evalSha< QJsonArray >( const QByteArray& sha, const QVariantList& keys,
                                          const QVariantList& argv );
template<>
QJsonArray Client::evalSha< QJsonArray >( const QByteArray& sha, const QVariantList& keys,
                                          const QVariantList& argv,
                                          int database, const QString& host, quint16 port );
template<>
std::vector< QJsonObject > Client::lrange< QJsonObject >( const QString & key, int from, int to,
                                                          int database, const QString & host, quint16 );

} // namespace redis

} // namespace myx

#ifdef MYXLIB_HEADER_ONLY
#include "client-inl.hpp"
#endif

// #include "client_redis.tcc"

#endif // ifndef MYX_REDIS_CLIENT_HPP_