// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "../zen.h"

#include "../authutils.h"

namespace zen {

class ProjectStoreCommand : public ZenCmdBase
{
	virtual ZenCmdCategory& CommandCategory() const override { return g_ProjectStoreCategory; }
};

class DropProjectCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "project-drop";
	static constexpr char Description[] = "Drop project or project oplog";

	DropProjectCommand();
	~DropProjectCommand();

	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
	std::string		 m_ProjectName;
	std::string		 m_OplogName;
	bool			 m_DryRun = true;
};

class ProjectInfoCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "project-info";
	static constexpr char Description[] = "Info on project or project oplog";

	ProjectInfoCommand();
	~ProjectInfoCommand();
	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
	std::string		 m_ProjectName;
	std::string		 m_OplogName;
};

class CreateProjectCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "project-create";
	static constexpr char Description[] = "Create a project";

	CreateProjectCommand();
	~CreateProjectCommand();

	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
	std::string		 m_ProjectId;
	std::string		 m_RootDir;
	std::string		 m_EngineRootDir;
	std::string		 m_ProjectRootDir;
	std::string		 m_ProjectFile;
	bool			 m_ForceUpdate = false;
};

class CreateOplogCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "oplog-create";
	static constexpr char Description[] = "Create a project oplog";

	CreateOplogCommand();
	~CreateOplogCommand();

	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
	std::string		 m_ProjectId;
	std::string		 m_OplogId;
	std::string		 m_GcPath;
	bool			 m_ForceUpdate = false;
};

class ExportOplogCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "oplog-export";
	static constexpr char Description[] = "Export project store oplog";

	ExportOplogCommand();
	~ExportOplogCommand();

	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
	std::string		 m_ProjectName;
	std::string		 m_OplogName;
	uint64_t		 m_MaxBlockSize		 = 0;
	uint64_t		 m_MaxChunksPerBlock = 0;
	uint64_t		 m_MaxChunkEmbedSize = 0;
	bool			 m_EmbedLooseFiles	 = false;
	bool			 m_Force			 = false;
	bool			 m_DisableBlocks	 = false;
	bool			 m_Async			 = false;

	std::string m_JupiterNamespace;
	std::string m_JupiterBucket;
	std::string m_JupiterOpenIdProvider;
	std::string m_JupiterAccessToken;
	std::string m_JupiterAccessTokenEnv;
	std::string m_JupiterAccessTokenPath;
	std::string m_OidcTokenAuthExecutablePath;
	bool		m_JupiterAssumeHttp2	   = false;
	bool		m_JupiterDisableTempBlocks = false;

	std::string m_CloudUrl;
	std::string m_CloudKey;
	std::string m_BaseCloudKey;

	std::string m_BuildsUrl;
	std::string m_BuildsId;
	std::string m_BuildsMetadataPath;
	std::string m_BuildsMetadata;

	bool m_BoostWorkerCount			= false;
	bool m_BoostWorkerMemory		= false;
	bool m_BoostWorkers				= false;
	bool m_IgnoreMissingAttachments = false;

	std::string m_ZenUrl;
	std::string m_ZenProjectName;
	std::string m_ZenOplogName;
	bool		m_ZenClean = false;

	std::string m_FileDirectoryPath;
	std::string m_FileName;
	std::string m_BaseFileName;
	bool		m_FileForceEnableTempBlocks = false;
	bool		m_PlainProgress				= false;
};

class ImportOplogCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "oplog-import";
	static constexpr char Description[] = "Import project store oplog";

	ImportOplogCommand();
	~ImportOplogCommand();

	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
	std::string		 m_ProjectName;
	std::string		 m_OplogName;
	std::string		 m_GcPath;
	bool			 m_Force					= false;
	bool			 m_Async					= false;
	bool			 m_IgnoreMissingAttachments = false;
	bool			 m_Clean					= false;
	bool			 m_PlainProgress			= false;

	std::string m_JupiterNamespace;
	std::string m_JupiterBucket;

	std::string m_JupiterOpenIdProvider;
	std::string m_JupiterAccessToken;
	std::string m_JupiterAccessTokenEnv;
	std::string m_JupiterAccessTokenPath;
	std::string m_OidcTokenAuthExecutablePath;
	bool		m_JupiterAssumeHttp2 = false;

	std::string m_CloudUrl;
	std::string m_ZenCacheHost;
	bool		m_UploadToZenCache = false;
	std::string m_CloudKey;

	std::string m_BuildsHost;
	std::string m_BuildsOverrideHost;
	std::string m_BuildsId;

	std::string m_ZenUrl;
	std::string m_ZenProjectName;
	std::string m_ZenOplogName;

	std::string m_FileDirectoryPath;
	std::string m_FileName;

	bool m_BoostWorkerCount	 = false;
	bool m_BoostWorkerMemory = false;
	bool m_BoostWorkers		 = false;

	std::string m_AllowPartialBlockRequests = "true";
};

class SnapshotOplogCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "oplog-snapshot";
	static constexpr char Description[] = "Snapshot project store oplog";

	SnapshotOplogCommand();
	~SnapshotOplogCommand();
	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
	std::string		 m_ProjectName;
	std::string		 m_OplogName;
};

class ProjectStatsCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "project-stats";
	static constexpr char Description[] = "Stats on project store";

	ProjectStatsCommand();
	~ProjectStatsCommand();
	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
};

class ProjectOpDetailsCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "project-op-details";
	static constexpr char Description[] = "Detail info on ops inside a project store oplog";

	ProjectOpDetailsCommand();
	~ProjectOpDetailsCommand();
	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
	bool			 m_Details			 = false;
	bool			 m_OpDetails		 = false;
	bool			 m_AttachmentDetails = false;
	bool			 m_CSV				 = false;
	std::string		 m_ProjectName;
	std::string		 m_OplogName;
	std::string		 m_OpId;
};

class OplogMirrorCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "oplog-mirror";
	static constexpr char Description[] = "Mirror project store oplog to file system";

	OplogMirrorCommand();
	~OplogMirrorCommand();
	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
	std::string		 m_ProjectName;
	std::string		 m_OplogName;
	std::string		 m_MirrorRootPath;
	std::string		 m_KeyFilter;
	std::string		 m_FilenameFilter;
	std::string		 m_ChunkIdFilter;
	bool			 m_Decompress		   = false;
	bool			 m_TrimToReferencedSet = true;
};

class OplogValidateCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "oplog-validate";
	static constexpr char Description[] = "Validate oplog for missing references";

	OplogValidateCommand();
	~OplogValidateCommand();
	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};
	std::string		 m_HostName;
	std::string		 m_ProjectName;
	std::string		 m_OplogName;
};

class OplogDownloadCommand : public ProjectStoreCommand
{
public:
	static constexpr char Name[]		= "oplog-download";
	static constexpr char Description[] = "Download an cloud storage oplog";

	OplogDownloadCommand();
	~OplogDownloadCommand();
	virtual void			  Run(const ZenCliOptions& GlobalOptions, int argc, char** argv) override;
	virtual cxxopts::Options& Options() override { return m_Options; }

private:
	cxxopts::Options m_Options{Name, Description};

	std::filesystem::path m_SystemRootDir;

	bool m_Quiet		 = false;
	bool m_Verbose		 = false;
	bool m_Yes			 = false;
	bool m_PlainProgress = false;
	bool m_LogProgress	 = false;

	AuthCommandLineOptions m_AuthOptions;

	// cloud builds
	std::string m_OverrideHost;
	std::string m_Host;
	std::string m_Url;
	bool		m_AssumeHttp2	= false;
	bool		m_AllowRedirect = false;
	std::string m_ZenCacheHost;
	std::string m_Namespace;
	std::string m_Bucket;
	std::string m_BuildId;
	bool		m_ForceDownload		= false;
	bool		m_BoostWorkerCount	= false;
	bool		m_BoostWorkerMemory = false;
	bool		m_BoostWorkers		= false;
	bool		m_UploadToZenCache	= true;

	std::filesystem::path m_OplogOutputPath;
	bool				  m_DecompressAttachments = true;

	std::vector<std::string> m_Attachments;
	std::filesystem::path	 m_AttachmentsPath;
};

}  // namespace zen