#pragma once
#include "SiaCommon.h"
#include "SiaCurl.h"
#include "AutoThread.h"
#include "UploadManager.h"

NS_BEGIN(Sia)
NS_BEGIN(Api)

class CSiaDriveConfig;
class AFX_EXT_CLASS CSiaBase
{
public:
	explicit CSiaBase(const CSiaCurl& siaCurl, CSiaDriveConfig* siaDriveConfig) :
		_siaCurl(siaCurl),
		_siaDriveConfig(siaDriveConfig)
	{
	}

public:
	virtual ~CSiaBase() = 0
	{
	}

private:
	const CSiaCurl& _siaCurl;
	CSiaDriveConfig* _siaDriveConfig;

protected:
	inline const CSiaCurl& GetSiaCurl() const
	{
		return _siaCurl;
	}

	inline CSiaDriveConfig& GetSiaDriveConfig() const
	{
		return *_siaDriveConfig;
	}
};


class AFX_EXT_CLASS CSiaApi
{
public:
	enum class _SiaApiError 
	{
		Success,
		NotImplemented,
		RequestError,
		WalletExists,
		WalletLocked,
		WalletUnlocked,
		WalletNotCreated
	};

	enum class _SiaSeedLanguage
	{
		English,
		German,
		Japanese
	};

	class _CSiaFileTree;
	class AFX_EXT_CLASS _CSiaFile :
		public virtual CSiaBase
	{
		friend CSiaApi;
		friend _CSiaFileTree;

	private:
		explicit _CSiaFile(const CSiaCurl& siaCurl, CSiaDriveConfig* siaDriveConfig, const json& fileJson);

	public:
		virtual ~_CSiaFile();

	// Properties
		Property(String, SiaPath, public, private)
		Property(std::uint64_t, FileSize, public, private)
		Property(bool, Available, public, private)
		Property(bool, Renewing, public, private)
		Property(std::uint32_t, Redundancy, public, private)
		Property(std::uint32_t, UploadProgress, public, private)
		Property(std::uint32_t, Expiration, public, private)
	};

	class AFX_EXT_CLASS _CSiaFileTree :
		public virtual CSiaBase
	{
		friend CSiaApi;
	public:
		explicit _CSiaFileTree(const CSiaCurl& siaCurl, CSiaDriveConfig* siaDriveConfig);

	public:
		virtual ~_CSiaFileTree();

	private:
		std::vector<std::shared_ptr<_CSiaFile>> _fileList;

	public:
		void BuildTree(const json& result);

		std::vector<std::shared_ptr<_CSiaFile>> GetFileList() const;

		std::vector<std::shared_ptr<_CSiaFile>> Query(String query) const;

		std::shared_ptr<_CSiaFile> GetFile(const String& siaPath) const;

		bool FileExists(const String& siaPath) const;
	};

	class AFX_EXT_CLASS _CSiaWallet :
		public virtual CSiaBase
	{
		friend CSiaApi;
	private:
		explicit _CSiaWallet(const CSiaCurl& siaCurl, CSiaDriveConfig* siaDriveConfig);

	public:
		virtual ~_CSiaWallet();

	// Properties
		Property(bool, Created, public, private)
		Property(bool, Locked, public, private)

	public:
		_SiaApiError Create(const _SiaSeedLanguage& seedLanguage, String& seed);
		bool Refresh();
		_SiaApiError Restore(const String& seed);
		_SiaApiError Lock();
		_SiaApiError Unlock(const String& password);
		_SiaApiError GetConfirmedBalance(SiaCurrency& balance) const;
		_SiaApiError GetUnonfirmedBalance(SiaCurrency& balance) const; 
		_SiaApiError GetAddress(String& address) const;
	};

	class AFX_EXT_CLASS _CSiaRenter :
		public virtual CSiaBase,
		public virtual CAutoThread
	{
		friend CSiaApi;

	private:
		explicit _CSiaRenter(const CSiaCurl& siaCurl, CSiaDriveConfig* siaDriveConfig);

	public:
		virtual ~_CSiaRenter();
		
		Property(SiaCurrency, Funds, public, private)
		Property(std::uint64_t, Hosts, public, private)
		Property(SiaCurrency, Unspent, public, private)
		Property(std::uint64_t, TotalUsedBytes, public, private)
		Property(std::uint32_t, TotalUploadProgress, public, private)

	private:
		CUploadManager _uploadManager;

	protected:
		virtual void AutoThreadCallback(const CSiaCurl& siaCurl, CSiaDriveConfig* siaDriveConfig) override;

	public:
		_SiaApiError FileExists(const String& siaPath, bool& exists) const;
		_SiaApiError DeleteFile(const String& siaPath);
		_SiaApiError DownloadFile(const String& siaPath, const String& location) const;
		_SiaApiError QueueUploadFile(const String& siaPath, const String& filePath);
		_SiaApiError GetFileTree(std::shared_ptr<_CSiaFileTree>& siaFileTree) const;
	};

	class AFX_EXT_CLASS _CSiaConsensus : 
		public virtual CSiaBase,
		public virtual CAutoThread
	{
		friend CSiaApi;

	private:
		explicit _CSiaConsensus(const CSiaCurl& siaCurl, CSiaDriveConfig* siaDriveConfig);

	public:
		virtual ~_CSiaConsensus();

	// Properties
		Property(std::uint64_t, Height, public, private)
		Property(bool, Synced, public, private)
		Property(String, CurrentBlock, public, private)

	protected:
		virtual void AutoThreadCallback(const CSiaCurl& siaCurl, CSiaDriveConfig* siaDriveConfig) override;
	};

public:
	explicit CSiaApi(const SiaHostConfig& hostConfig, CSiaDriveConfig* siaDriveConfig);

public:
	~CSiaApi();

private:
	CSiaCurl _siaCurl;
	CSiaDriveConfig* _siaDriveConfig;
	std::shared_ptr<_CSiaWallet> _wallet;
	std::shared_ptr<_CSiaRenter> _renter;
	std::shared_ptr<_CSiaConsensus> _consensus;

public:
	static String FormatToSiaPath(String path);

public:
	std::shared_ptr<_CSiaWallet> GetWallet() const;
	std::shared_ptr<_CSiaRenter> GetRenter() const;
	std::shared_ptr<_CSiaConsensus> GetConsensus() const;
	String GetServerVersion() const;
};

typedef CSiaApi::_SiaApiError SiaApiError;
typedef CSiaApi::_SiaSeedLanguage SiaSeedLanguage;
typedef CSiaApi::_CSiaWallet CSiaWallet;
typedef CSiaApi::_CSiaRenter CSiaRenter;
typedef CSiaApi::_CSiaConsensus CSiaConsensus;
typedef std::shared_ptr<CSiaWallet> CSiaWalletPtr;
typedef std::shared_ptr<CSiaRenter> CSiaRenterPtr;
typedef std::shared_ptr<CSiaConsensus> CSiaConsensusPtr;
typedef CSiaApi::_CSiaFile CSiaFile;
typedef std::shared_ptr<CSiaFile> CSiaFilePtr;
typedef std::vector<CSiaFilePtr> CSiaFileCollection;
typedef CSiaApi::_CSiaFileTree CSiaFileTree;
typedef std::shared_ptr<CSiaFileTree> CSiaFileTreePtr;

NS_END(2)