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

#pragma once

#include "OnlineKeyValuePair.h"
#include "OnlineSubsystem.h"

#define UE_API ONLINESUBSYSTEM_API

// NOTE:  Session setting names have been moved to OnlineBase in OnlineSessionNames.h

#define INVALID_SESSION_SETTING_ID -1

/**
 *	One setting describing an online session
 * contains a key, value and how this setting is advertised to others, if at all
 */
struct FOnlineSessionSetting
{
public:
	/** Settings value */
	FVariantData Data;
	/** How is this session setting advertised with the backend or searches */
	EOnlineDataAdvertisementType::Type AdvertisementType;
	/** Optional ID used in some platforms as the index instead of the session name */
	int32 ID;

public:
	/** Default constructor, used when serializing a network packet */
	FOnlineSessionSetting()
		: AdvertisementType(EOnlineDataAdvertisementType::DontAdvertise)
		, ID(INVALID_SESSION_SETTING_ID)
	{
	}

	/** Constructor for settings created/defined on the host for a session */
	template<typename Type>
	FOnlineSessionSetting(Type&& InData)
		: Data(Forward<Type>(InData))
		, AdvertisementType(EOnlineDataAdvertisementType::DontAdvertise)
		, ID(INVALID_SESSION_SETTING_ID)
	{
	}

	/** Constructor for settings created/defined on the host for a session */
	template<typename Type>
	FOnlineSessionSetting(Type&& InData, EOnlineDataAdvertisementType::Type InAdvertisementType)
		: Data(Forward<Type>(InData))
		, AdvertisementType(InAdvertisementType)
		, ID(INVALID_SESSION_SETTING_ID)
	{
	}

	/** Constructor for settings created/defined on the host for a session */
	template<typename Type>
	FOnlineSessionSetting(Type&& InData, EOnlineDataAdvertisementType::Type InAdvertisementType, int32 InID)
		: Data(Forward<Type>(InData))
		, AdvertisementType(InAdvertisementType)
		, ID(InID)
	{
	}

	/**
	*	Comparison operator
	*/
	bool operator==(const FOnlineSessionSetting& Other) const
	{
		// Advertisement type not compared because it is not passed to clients
		return Data == Other.Data;
	}

	bool operator!=(const FOnlineSessionSetting& Other) const
	{
		return !operator==(Other);
	}

	FString ToString() const
	{
		if (ID == INVALID_SESSION_SETTING_ID)
		{
			return FString::Printf(TEXT("%s : %s"), *Data.ToString(), EOnlineDataAdvertisementType::ToString(AdvertisementType));
		}
		else
		{
			return FString::Printf(TEXT("%s : %s : %d"), *Data.ToString(), EOnlineDataAdvertisementType::ToString(AdvertisementType), ID);
		}
	}
};

/** Type defining an array of session settings accessible by key */
typedef FOnlineKeyValuePairs<FName, FOnlineSessionSetting> FSessionSettings;

/**
 *	One search parameter in an online session query
 *  contains a value and how this setting is compared
 */
class FOnlineSessionSearchParam
{
private:
	/** Hidden on purpose */
	FOnlineSessionSearchParam() = delete;

public:
	/** Search value */
	FVariantData Data;
	/** How is this session setting compared on the backend searches */
	EOnlineComparisonOp::Type ComparisonOp;
	/** Optional ID used on some platform to index the session setting */
	int32 ID;

public:
	/** Constructor for setting search parameters in a query */
	template<typename Type>
	FOnlineSessionSearchParam(Type&& InData)
		: Data(Forward<Type>(InData))
		, ComparisonOp(EOnlineComparisonOp::Equals)
		, ID(INVALID_SESSION_SETTING_ID)
	{
	}

	/** Constructor for setting search parameters in a query */
	template<typename Type>
	FOnlineSessionSearchParam(Type&& InData, EOnlineComparisonOp::Type InComparisonOp)
		: Data(Forward<Type>(InData))
		, ComparisonOp(InComparisonOp)
		, ID(INVALID_SESSION_SETTING_ID)
	{
	}

	/** Constructor for setting search parameters in a query */
	template<typename Type>
	FOnlineSessionSearchParam(Type&& InData, EOnlineComparisonOp::Type InComparisonOp, int32 InID)
		: Data(Forward<Type>(InData))
		, ComparisonOp(InComparisonOp)
		, ID(InID)
	{
	}

	/**
	 *	Comparison operator
	 */
	bool operator==(const FOnlineSessionSearchParam& Other) const
	{
		// Don't compare ComparisonOp so we don't get the same data with different ops
		return Data == Other.Data;
	}

	bool operator!=(const FOnlineSessionSearchParam& Other) const
	{
		return !operator==(Other);
	}

	FString ToString() const
	{
		return FString::Printf(TEXT("Value=%s : %s : %d"), *Data.ToString(), EOnlineComparisonOp::ToString(ComparisonOp), ID);
	}
};

/** Type defining an array of search parameters accessible by key */
typedef FOnlineKeyValuePairs<FName, FOnlineSessionSearchParam> FSearchParams;

/**
 *	Container for all parameters describing a single session search
 */
class FOnlineSearchSettings
{
public:
	/** Array of custom search settings */
	FSearchParams SearchParams;

public:
	FOnlineSearchSettings() = default;

	FOnlineSearchSettings(FOnlineSearchSettings&&) = default;
	FOnlineSearchSettings(const FOnlineSearchSettings&) = default;
	FOnlineSearchSettings& operator=(FOnlineSearchSettings&&) = default;
	FOnlineSearchSettings& operator=(const FOnlineSearchSettings&) = default;

	virtual ~FOnlineSearchSettings() = default;

	/**
	 *	Sets a key value pair combination that defines a search parameter
	 *
	 * @param Key key for the setting
	 * @param Value value of the setting
	 * @param InType type of comparison
	 * @param ID ID of comparison
	 */
	template<typename ValueType>
	ONLINESUBSYSTEM_API void Set(FName Key, const ValueType& Value, EOnlineComparisonOp::Type InType, int32 ID);

	/**
	 *	Sets a key value pair combination that defines a search parameter
	 *
	 * @param Key key for the setting
	 * @param Value value of the setting
	 * @param InType type of comparison
	 */
	template<typename ValueType>
	ONLINESUBSYSTEM_API void Set(FName Key, const ValueType& Value, EOnlineComparisonOp::Type InType);

	/**
	 *	Gets a key value pair combination that defines a search parameter
	 *
	 * @param Key key for the setting
	 * @param Value value of the setting
	 *
	 * @return true if found, false otherwise
	 */
	template<typename ValueType>
	ONLINESUBSYSTEM_API bool Get(FName Key, ValueType& Value) const;

	/**
	 * Retrieve a search parameter comparison op
	 *
	 * @param Key key of the setting
	 *
	 * @return the comparison op for the setting
	 */
	UE_API EOnlineComparisonOp::Type GetComparisonOp(FName Key) const;
};

/**
 *	Container for all settings describing a single online session
 */
class FOnlineSessionSettings
{
public:
	/** The number of publicly available connections advertised */
	int32 NumPublicConnections;
	/** The number of connections that are private (invite/password) only */
	int32 NumPrivateConnections;
	/** Whether this match is publicly advertised on the online service */
	bool bShouldAdvertise;
	/** Whether joining in progress is allowed or not */
	bool bAllowJoinInProgress;
	/** This game will be lan only and not be visible to external players */
	bool bIsLANMatch;
	/** Whether the server is dedicated or player hosted */
	bool bIsDedicated;
	/** Whether the match should gather stats or not */
	bool bUsesStats;
	/** Whether the match allows invitations for this session or not */
	bool bAllowInvites;
	/** Whether to display user presence information or not */
	bool bUsesPresence;
	/** Whether joining via player presence is allowed or not */
	bool bAllowJoinViaPresence;
	/** Whether joining via player presence is allowed for friends only or not */
	bool bAllowJoinViaPresenceFriendsOnly;
	/** Whether the server employs anti-cheat (punkbuster, vac, etc) */
	bool bAntiCheatProtected;
	/** Whether to prefer lobbies APIs if the platform supports them */
	bool bUseLobbiesIfAvailable;
	/** Whether to create (and auto join) a voice chat room for the lobby, if the platform supports it */
	bool bUseLobbiesVoiceChatIfAvailable;
	/** Manual override for the Session Id instead of having one assigned by the backend. Its size may be restricted depending on the platform */
	FString SessionIdOverride;

	/** Used to keep different builds from seeing each other during searches */
	int32 BuildUniqueId;
	/** Array of custom session settings */
	FSessionSettings Settings;

	/** Map of custom settings per session member (Not currently used by every OSS) */
	TUniqueNetIdMap<FSessionSettings> MemberSettings;

public:
	/** Default constructor, used when serializing a network packet */
	FOnlineSessionSettings()
		: NumPublicConnections(0)
		, NumPrivateConnections(0)
		, bShouldAdvertise(false)
		, bAllowJoinInProgress(false)
		, bIsLANMatch(false)
		, bIsDedicated(false)
		, bUsesStats(false)
		, bAllowInvites(false)
		, bUsesPresence(false)
		, bAllowJoinViaPresence(false)
		, bAllowJoinViaPresenceFriendsOnly(false)
		, bAntiCheatProtected(false)
		, bUseLobbiesIfAvailable(false)
		, bUseLobbiesVoiceChatIfAvailable(false)
		, BuildUniqueId(GetBuildUniqueId())
	{
		// Example usage of settings
//		Set(SETTING_MAPNAME, FString(TEXT("")), EOnlineDataAdvertisementType::ViaOnlineService);
//		Set(SETTING_NUMBOTS, 0, EOnlineDataAdvertisementType::ViaOnlineService);
//		Set(SETTING_GAMEMODE, FString(TEXT("")), EOnlineDataAdvertisementType::ViaOnlineService);
	}

	virtual ~FOnlineSessionSettings()
	{
	}

	FOnlineSessionSettings(FOnlineSessionSettings&&) = default;
	FOnlineSessionSettings(const FOnlineSessionSettings&) = default;
	FOnlineSessionSettings& operator=(FOnlineSessionSettings&&) = default;
	FOnlineSessionSettings& operator=(const FOnlineSessionSettings&) = default;

	/**
	 *	Sets a key value pair combination that defines a session setting with an ID
	 *
	 * @param Key key for the setting
	 * @param Value value of the setting
	 * @param InType type of online advertisement
	 * @param ID ID for this session setting
	 */
	template<typename ValueType>
	ONLINESUBSYSTEM_API void Set(FName Key, const ValueType& Value, EOnlineDataAdvertisementType::Type InType, int32 InID);

	/**
	 *	Sets a key value pair combination that defines a session setting
	 *
	 * @param Key key for the setting
	 * @param Value value of the setting
	 * @param InType type of online advertisement
	 */
	template<typename ValueType>
	ONLINESUBSYSTEM_API void Set(FName Key, const ValueType& Value, EOnlineDataAdvertisementType::Type InType);

	/**
	 *	Sets a key value pair combination that defines a session setting
	 * from an existing session setting
	 *
	 * @param Key key for the setting
	 * @param SrcSetting setting values
	 */
	ONLINESUBSYSTEM_API void Set(FName Key, const FOnlineSessionSetting& SrcSetting);

	/**
	 *	Gets a key value pair combination that defines a session setting
	 *
	 * @param Key key for the setting
	 * @param Value value of the setting
	 *
	 * @return true if found, false otherwise
	 */
	template<typename ValueType>
	ONLINESUBSYSTEM_API bool Get(FName Key, ValueType& Value) const;

	/**
	 *  Removes a key value pair combination
	 *
	 * @param Key key to remove
	 *
	 * @return true if found and removed, false otherwise
	 */
	ONLINESUBSYSTEM_API bool Remove(FName Key);

	/**
	 * Retrieve a session setting's advertisement type
	 *
	 * @param Key key of the setting
	 *
	 * @return the advertisement type for the setting
	 */
	ONLINESUBSYSTEM_API EOnlineDataAdvertisementType::Type GetAdvertisementType(FName Key) const;

	/**
	* Retrieve a session setting's ID
	*
	* @param Key key of the setting
	*
	* @return the ID for the setting
	*/
	ONLINESUBSYSTEM_API int32 GetID(FName Key) const;

};

/** Basic session information serializable into a NamedSession or SearchResults */
class FOnlineSession
{
public:
	/** Owner of the session */
	FUniqueNetIdPtr OwningUserId;
	/** Owner name of the session */
	FString OwningUserName;
	/** The settings associated with this session */
	FOnlineSessionSettings SessionSettings;
	/** The platform specific session information */
	TSharedPtr<class FOnlineSessionInfo> SessionInfo;
	/** The number of private connections that are available (read only) */
	int32 NumOpenPrivateConnections;
	/** The number of publicly available connections that are available (read only) */
	int32 NumOpenPublicConnections;

public:
	/** Default constructor, used when serializing a network packet */
	FOnlineSession() :
		OwningUserId(nullptr),
		SessionInfo(nullptr),
		NumOpenPrivateConnections(0),
		NumOpenPublicConnections(0)
	{
	}

	/** Constructor */
	FOnlineSession(const FOnlineSessionSettings& InSessionSettings) :
		OwningUserId(nullptr),
		SessionSettings(InSessionSettings),
		SessionInfo(nullptr),
		NumOpenPrivateConnections(0),
		NumOpenPublicConnections(0)
	{
	}

	FOnlineSession(FOnlineSession&&) = default;
	FOnlineSession(const FOnlineSession&) = default;
	FOnlineSession& operator=(FOnlineSession&&) = default;
	FOnlineSession& operator=(const FOnlineSession&) = default;

	virtual ~FOnlineSession() = default;

	/** @return the session id for the session as a string */
	FString GetSessionIdStr() const
	{
		if (SessionInfo.IsValid() && SessionInfo->IsValid())
		{
			return SessionInfo->GetSessionId().ToString();
		}

		return TEXT("InvalidSession");
	}
};

/** Holds the per session information for named sessions */
class FNamedOnlineSession : public FOnlineSession
{
protected:
	FNamedOnlineSession() :
		SessionName(NAME_None),
		HostingPlayerNum(INDEX_NONE),
		SessionState(EOnlineSessionState::NoSession)
	{
	}

public:
	/** The name of the session */
	const FName SessionName;
	/** Index of the player who created the session [host] or joined it [client] */
	int32 HostingPlayerNum;
	/** Whether or not the local player is hosting this session */
	bool bHosting;

	/** NetId of the local player that created this named session.  Could be the host, or a player joining a session. Will entirely replace HostingPlayerNum */
	FUniqueNetIdPtr LocalOwnerId;

	/** List of players registered in the session */
	TArray< FUniqueNetIdRef > RegisteredPlayers;
	/** State of the session (game thread write only) */
	EOnlineSessionState::Type SessionState;

	/** Constructor used to create a named session directly */
	FNamedOnlineSession(FName InSessionName, const FOnlineSessionSettings& InSessionSettings)
		: FOnlineSession(InSessionSettings)
		, SessionName(InSessionName)
		, HostingPlayerNum(INDEX_NONE)
		, bHosting(false)
		, SessionState(EOnlineSessionState::NoSession)
	{
	}

	/** Constructor used to create a named session directly */
	FNamedOnlineSession(FName InSessionName, const FOnlineSession& Session)
		: FOnlineSession(Session)
		, SessionName(InSessionName)
		, HostingPlayerNum(INDEX_NONE)
		, bHosting(false)
		, SessionState(EOnlineSessionState::NoSession)
	{
	}

	virtual ~FNamedOnlineSession()
	{
	}

	FNamedOnlineSession(const FNamedOnlineSession& Other) = default;
	FNamedOnlineSession(FNamedOnlineSession&& Other) = default;

	// We delete the equals operator as SessionName is immutable
	FNamedOnlineSession& operator=(const FNamedOnlineSession& Other) = delete;
	FNamedOnlineSession& operator=(FNamedOnlineSession&& Other) = delete;

	/**
	 * Calculate the possible joinability state of this session
	 * check the values from left to right in order of precedence
	 *
	 * @param bPublicJoinable [out] is the game joinable by anyone at all
	 * @param bFriendJoinable [out] is the game joinable by friends via presence (doesn't require invite)
	 * @param bInviteOnly [out] is the game joinable via explicit invites
	 * @param bAllowInvites [out] are invites possible (use with bInviteOnly to determine if invites are available right now)
	 *
	 * @return true if the out params are valid, false otherwise
	 */
	bool GetJoinability(bool& bPublicJoinable, bool& bFriendJoinable, bool& bInviteOnly, bool& bAllowInvites) const
	{
		// Only states that have a valid session are considered
		if (SessionState != EOnlineSessionState::NoSession && SessionState != EOnlineSessionState::Creating && SessionState != EOnlineSessionState::Destroying)
		{
			bool bAllowJIP = SessionSettings.bAllowJoinInProgress || (SessionState != EOnlineSessionState::Starting && SessionState != EOnlineSessionState::InProgress);
			if (bAllowJIP)
			{
				bPublicJoinable = SessionSettings.bShouldAdvertise || SessionSettings.bAllowJoinViaPresence;
				bFriendJoinable = SessionSettings.bAllowJoinViaPresenceFriendsOnly;
				bInviteOnly = !bPublicJoinable && !bFriendJoinable && SessionSettings.bAllowInvites;
				bAllowInvites = SessionSettings.bAllowInvites;
			}
			else
			{
				bPublicJoinable = false;
				bFriendJoinable = false;
				bInviteOnly = false;
				bAllowInvites = false;
			}

			// Valid session, joinable or otherwise
			return true;
		}

		// Invalid session
		return false;
	}
};

using FNamedOnlineSessionPtr = TSharedPtr<FNamedOnlineSession, ESPMode::ThreadSafe>;
using FNamedOnlineSessionRef = TSharedRef<FNamedOnlineSession, ESPMode::ThreadSafe>;

/** Value returned on unreachable or otherwise bad search results */
#define MAX_QUERY_PING 9999

/** Representation of a single search result from a FindSession() call */
class FOnlineSessionSearchResult
{
public:
	/** All advertised session information */
	FOnlineSession Session;
	/** Ping to the search result, MAX_QUERY_PING is unreachable */
	int32 PingInMs;

	FOnlineSessionSearchResult()
		: PingInMs(MAX_QUERY_PING)
	{
	}

	/**
	 *	@return true if the search result is valid, false otherwise
	 */
	bool IsValid() const
	{
		return (Session.OwningUserId.IsValid() && IsSessionInfoValid());
	}

	/** 
	 * Check if the session info is valid, for cases where we don't need the OwningUserId
	 * @return true if the session info is valid, false otherwise
	 */
	bool IsSessionInfoValid() const
	{
		return (Session.SessionInfo.IsValid() && Session.SessionInfo->IsValid());
	}

	/** @return the session id for a given session search result */
	FString GetSessionIdStr() const
	{
		return Session.GetSessionIdStr();
	}
};

/**
 * Encapsulation of a search for sessions request.
 * Contains all the search parameters and any search results returned after
 * the OnFindSessionsCompleteDelegate has triggered
 * Check the SearchState for Done/Failed state before using the data
 */
class FOnlineSessionSearch
{
public:
	/** Array of all sessions found when searching for the given criteria */
	TArray<FOnlineSessionSearchResult> SearchResults;
	/** State of the search */
	EOnlineAsyncTaskState::Type SearchState;
	/** Max number of queries returned by the matchmaking service */
	int32 MaxSearchResults;
	/** The query to use for finding matching servers */
	FOnlineSearchSettings QuerySettings;
	/** Whether the query is intended for LAN matches or not */
	bool bIsLanQuery;
	/**
	 * Used to sort games into buckets since a the difference in terms of feel for ping
	 * in the same bucket is often not a useful comparison and skill is better
	 */
	int32 PingBucketSize;
	/** Search hash used by the online subsystem to disambiguate search queries, stamped every time FindSession is called */
	int32 PlatformHash;
	/** Amount of time to wait for the search results. May not apply to all platforms. */
	float TimeoutInSeconds;

public:
	/** Constructor */
	FOnlineSessionSearch()
		: SearchState(EOnlineAsyncTaskState::NotStarted)
		, MaxSearchResults(1)
		, bIsLanQuery(false)
		, PingBucketSize(0)
		, PlatformHash(0)
		, TimeoutInSeconds(0.0f)
	{
		// Examples of setting search parameters
		// QuerySettings.Set(SETTING_MAPNAME, FString(), EOnlineComparisonOp::Equals);
		// QuerySettings.Set(SEARCH_DEDICATED_ONLY, false, EOnlineComparisonOp::Equals);
		// QuerySettings.Set(SEARCH_EMPTY_SERVERS_ONLY, false, EOnlineComparisonOp::Equals);
		// QuerySettings.Set(SEARCH_SECURE_SERVERS_ONLY, false, EOnlineComparisonOp::Equals);
	}

	virtual ~FOnlineSessionSearch()
	{
	}

	FOnlineSessionSearch(FOnlineSessionSearch&&) = default;
	FOnlineSessionSearch(const FOnlineSessionSearch&) = default;
	FOnlineSessionSearch& operator=(FOnlineSessionSearch&&) = default;
	FOnlineSessionSearch& operator=(const FOnlineSessionSearch&) = default;

	/**
	 *	Give the game a chance to sort the returned results
	 */
	virtual void SortSearchResults() {}

	/**
	 * Get the default session settings for this search type
	 * Allows games to set reasonable defaults that aren't advertised
	 * but would be setup for each instantiated search result
	 */
	virtual TSharedPtr<FOnlineSessionSettings> GetDefaultSessionSettings() const
	{
		return MakeShared<FOnlineSessionSettings>();
	}
};

/**
 * Logs session properties used from the session settings
 *
 * @param NamedSession the session to log the information for
 */
void ONLINESUBSYSTEM_API DumpNamedSession(const FNamedOnlineSession* NamedSession);

/**
 * Logs session properties used from the session settings
 *
 * @param Session the session to log the information for
 */
void ONLINESUBSYSTEM_API DumpSession(const FOnlineSession* Session);

/**
 * Logs session properties used from the session settings
 *
 * @param SessionSettings the session to log the information for
 */
void ONLINESUBSYSTEM_API DumpSessionSettings(const FOnlineSessionSettings* SessionSettings);

#undef UE_API