#pragma once
namespace Rimage { namespace Rapid { namespace Impl {

class InternClientSession;
class WinSubclasser;

}}}

namespace Rimage { namespace Rapid { namespace Api {

class Connection;
class ISessionStatusListener;
class IJobStatusListener;
class IXmlModifyListener;
class ServerAlert;
class ImageOnlyJob;
class ProductionOnlyJob;
class ImageAndRecordJob;

/// <summary>
///		Working with the Rapid API starts with initiating a client session with the Rimage system. 
///		The ClientSession class is the base class for all sessions. It exposes methods that are common to all types 
///		of sessions, such as job creation, enumerating over jobs, servers, and alerts, and setting job and session listeners.
/// </summary>
/// <remarks>
///		An application maintains a reference to one and only one session object. 
/// </remarks>
/// <remarks>
///		This class is never instantiated by the caller directly. Call the static method SingleConnectionSession.GetInstance()
///		to get an instance of a session.
/// </remarks>
///	<para>
///		Rimage Corporation, Copyright (c) 2007
///	</para>
class SIMPLECLIENT_API ClientSession
{
public:
	// No public constructor
	virtual ~ClientSession();

	///	<summary>
	///		Connects to the Rimage messaging server.
	///	</summary>
	/// <remarks>
	///		A connection has to be established prior to submitting jobs.
	/// </remarks>
	///	<param name="clientId">An ID string that uniquely identifies the client application.</param>
	///	<param name="host">Computer name hosting the messaging server. Defaulted to "localhost".</param>
	///	<param name="port">The port messaging server is listening on. Defaulted to "4664".</param>
	///	<returns>A pointer to a new Connection object if successful, otherwise a RimageException is thrown.</returns>
	///	<exception cref="RimageException">Thrown when host or port are invalid, or the connection cannot be established.</exception>
	virtual Connection* Connect(LPCTSTR clientId, LPCTSTR host=NULL, LPCTSTR port=NULL);
	
	///	<summary>
	///		Creates an ImageOnlyJob object or one of its subclasses. The jobType has to be between ImageOnlyJobType and UserImageOnlyJobTypeLast.
	///	</summary>
	///	<param name="jobType">Identifies the specific Image Only job type.</param>
	///	<returns>A pointer to a new ImageOnlyJob object if successful, otherwise a RimageException is thrown.</returns>
	///	<exception cref="RimageException">Thrown when jobType is out of range.</exception>
	ImageOnlyJob* CreateImageOnlyJob(JobType jobType);
	
	///	<summary>
	///		Creates a ProductionOnlyJob object or one of its subclasses. The jobType should be between ProductionOnlyJobType and UserProductionOnlyJobTypeLast.
	///	</summary>
	///	<param name="jobType">Identifies the specific Production Only job type.</param>
	///	<returns>A pointer to a new ProductionOnlyJob object if successful, otherwise RimageException is thrown.</returns>
	///	<exception cref="RimageException">Thrown when jobType is out of range.</exception>
	ProductionOnlyJob* CreateProductionOnlyJob(JobType jobType);
	
	///	<summary>
	///		Creates an ImageAndRecordJob object or one of its subclasses. The jobType should be between ImageAndRecordJobType and UserImageAndRecordJobTypeLast.
	///	</summary>
	///	<param name="jobType">Identifies the specific Image and Record job type.</param>
	///	<returns>A pointer to a new ImageAndRecordJob object if successful, otherwise RimageException is thrown.</returns>
	///	<exception cref="RimageException">Thrown when jobType is out of range.</exception>
	ImageAndRecordJob* CreateImageAndRecordJob(JobType jobType);
	
	///	<summary>
	///		Initializes a JobIterator object to enable enumeration over created Job objects.
	///	</summary>
	///	<param name="iter">Reference to the JobIterator object to initialize.</param>
	///	<returns>void</returns>
	void InitJobIterator(JobIterator &iter);

	///	<summary>
	///		Retrieves a specific Job object which has been created by the API.
	///	</summary>
	///	<param name="jobId">ID of the job to retrieve.</param>
	///	<returns>A pointer to the Job object if sucessful, otherwise NULL.</returns>
	Job* GetCreatedJob(LPCTSTR jobId);

	///	<summary>
	///		Cancels a submitted job.
	///	</summary>
	///	<param name="jobId">The ID of the job to cancel.</param>
	///	<returns>void</returns>
	///	<exception cref="RimageException">Thrown in case the job with the given ID does not exist.</exception>
	void CancelJob(LPCTSTR jobId);

	///	<summary>
	///		Sets session listener for asynchronously receiving system-wide events, such as server state changes and server alerts. 
	///	</summary>
	///	<param name="statusListener">An object of a class that implements the ISessionStatusListener interface.</param>
	///	<param name="callbackType">A flag to indicate if the caller intends to have the listener called
	///		in the main UI thread of the client application, defaulted to UITrue. For non-UI applications, this
	///		should always be UIFalse. </param>
	///	<returns>void</returns>
	///	<exception cref="RimageException">Thrown when callbackType is true but no UI thread is found in the application.</exception>
	void SetSessionStatusListener(ISessionStatusListener *statusListener, CallbackOnMainUIThread callbackType=UITrue);
	
	///	<summary>
	///		Sets session listener for asynchronously receiving system-wide events, such as server state changes and server alerts. 
	///	</summary>
	///	<param name="statusListener">An object of a class that implements the ISessionStatusListener interface.</param>
	///	<param name="callbackUIThreadId">The thread ID that the caller intends to have the listener called in. 
	///		The thread should be a UI thread.</param>
	///	<returns>void</returns>
	///	<exception cref="RimageException">Thrown when callbackUIThreadId is an invalid thread ID or the thread does not
	///	have a UI window attached.</exception>
	void SetSessionStatusListener(ISessionStatusListener *statusListener, DWORD callbackUIThreadId);

	///	<summary>
	///		Sets the default job listener for asynchronously receiving job progress statuses.
	///	</summary>
	/// <remarks>
	///		A job listener can also be set with the specific job object.
	/// </remarks>
	///	<param name="statusListener">An object of a class that implements the IJobStatusListener interface.</param>
	///	<param name="callbackType">A flag to indicate if the caller intends to have the listener called
	///		in the main UI thread of the client application, defaulted to UITrue. For non-UI applications, this
	///		should always be UIFalse. 
	///	 </param>
	///	<returns>void</returns>
	///	<exception cref="RimageException">Thrown when callbackType is true but no UI thread is found in the application.</exception>
	void SetDefaultJobListener(IJobStatusListener *statusListener, CallbackOnMainUIThread callbackType=UITrue);

	///	<summary>
	///		Sets the default job listener for asynchronously receiving job progress statuses.
	///	</summary>
	/// <remarks>
	///		A job listener can also be set with the specific job object.
	/// </remarks>
	///	<param name="statusListener">An object of a class that implements the IJobStatusListener interface.</param>
	///	<param name="callbackUIThreadId">The thread ID that the caller intends to have the listener called in. 
	///		The thread should be a UI thread.</param>
	///	<returns>void</returns>
	///	<exception cref="RimageException">Thrown when callbackUIThreadId is an invalid thread ID or the thread does not
	///		have a UI Window attached.</exception>
	void SetDefaultJobListener(IJobStatusListener *statusListener, DWORD callbackUIThreadId);

	///	<summary>
	///		Returns the session status listener.
	///	</summary>
	///	<returns>Pointer to an object which implements ISessionStatusListener if one was set, NULL otherwise.</returns>
	ISessionStatusListener* GetSessionStatusListener();

	///	<summary>
	///		Removes the session status listener to stop recieving session related events.
	///	</summary>
	/// <remarks>
	///		It is not necessary to call this
	///		method at the end of a client session, the system will call this automatically.
	/// </remarks>
	///	<returns>void</returns>
	///	<exception cref="RimageException">Thrown in case of an internal problem.</exception>
	void RemoveSessionStatusListener();

	///	<summary>
	///		Returns the default job status listener.
	///	</summary>
	///	<returns>Pointer to an object which implements IJobStatusListener if one was set, NULL otherwise.</returns>
	IJobStatusListener* GetDefaultJobListener();

	///	<summary>
	///		Removes the default job status listener to stop recieving job statuses. 
	///	</summary>
	/// <remarks>
	///		It is not necessary to call this
	///		method at the end of a client session, the system will call this automatically.
	/// </remarks>
	///	<returns>void</returns>
	///	<exception cref="RimageException">Thrown in case of an internal problem.</exception>
	void RemoveDefaultJobListener();

	///	<summary>
	///		Sets the listener for modifying XML strings before they are sent to servers.
	///	</summary>
	void SetXmlModifyListener(IXmlModifyListener *pXmlModifyListener);

	///	<summary>
	///		Removes the listener for modifying XML if it was set.
	///	</summary>
	void RemoveXmlModifyListener();

	///	<summary>
	///		Sets a user defined Job factory. This method is optional unless you are creating new Job types.
	///	</summary>
	/// <remarks>
	///		Rapid API uses an internal job factory for Rimage predefined job types.
	/// </remarks>
	///	<param name="jobFactory">An object of a class that implements the IJobFactory interface.</param>
	///	<returns>void</returns>
	void SetUserJobFactory(IJobFactory *jobFactory);
	
	///	<summary>
	///		Returns the user defined Job factory. 
	///	</summary>
	///	<returns>Pointer to an object which implements IJobFactory if one was set, NULL otherwise.</returns>
	IJobFactory* GetUserJobFactory();

	///	<summary>
	///		Removes the user defined Job factory if one has been set by calling SetUserJobFactory(). 
	///	</summary>
	/// <remarks>
	///		Rapid API does not delete the user defined IJobFactory object, it just removes it from its list.
	/// </remarks>
	///	<returns>void</returns>
	void RemoveUserJobFactory();
	
	///	<summary>
	///		Sets a user defined XML writer factory. This method is optional unless you are altering the way XML
	///		orders are generated. Rapid API uses an internal XML writer factory for Rimage predefined XML writers.
	///	</summary>
	///	<param name="xmlWriterFactory">An object of a class that implements the IXmlWriterFactory interface.</param>
	///	<returns>void</returns>
	void SetUserXmlWriterFactory(IXmlWriterFactory *xmlWriterFactory);	

	///	<summary>
	///		Returns the user defined XML writer factory. 
	///	</summary>
	///	<returns>Pointer to an object which implements IXmlWriterFactory if one was set, NULL otherwise.</returns>
	IXmlWriterFactory* GetUserXmlWriterFactory();

	///	<summary>
	///		Removes the user defined IXmlWriterFactory object if one has been set by calling SetUserXmlWriterFactory(). 
	/// <remarks>
	///		Rapid API does not delete the user specified IXmlWriterFactory object, it just removes it from its list.
	/// </remarks>
	///	</summary>
	///	<returns>void</returns>
	void RemoveUserXmlWriterFactory();

	///	<summary>
	///		Initializes a ServerIterator object to enable enumeration over all Server objects in the system.
	///	</summary>
	///	<param name="iter">Reference to the ServerIterator object to initialize.</param>
	///	<returns>void</returns>
	void InitServerIterator(ServerIterator& iter);

	///	<summary>
	///		Retrieves a specific server object with the given connection ID and server ID.
	///	</summary>
	///	<param name="connectionId">Connection ID for the intended server. This identifies the connection this server is active on, obtained by calling Connection.GetConnectionId().</param>
	///	<param name="serverId">Server ID for the intended server.</param>
	///	<returns>A pointer to a Server object if successful, NULL if no server exists for
	///	the given connection ID and server ID.</returns>
	///	<exception cref="RimageException">Thrown if the server ID and/or connection ID is invalid.</exception>
	Server* GetServer(LPCTSTR connectionId, LPCTSTR serverId);

	///	<summary>
	///		Removes offline Server objects from Rapid APIs internal lists. 
	///	</summary>
	/// <remarks>
	///		Main reason for calling this method is to free application's memory.
	/// </remarks>
	///	<returns>void</returns>
	void RemoveOfflineServers();

	///	<summary>
	///		Initializes a ServerAlertIterator object to enable enumeration over all ServerAlert objects in the system.
	///	</summary>
	///	<param name="iter">Reference to the ServerAlertIterator object to initialize.</param>
	///	<returns>void</returns>
	void InitServerAlertIterator(ServerAlertIterator &iter);

	///	<summary>
	///		Retrieves a specific ServerAlert object with the given server ID and alert ID.
	///	</summary>
	///	<param name="serverId">Server ID for the server this alert is for.</param>
	///	<param name="alertId">Alert ID for the specific server alert.</param>
	///	<returns>A pointer to a ServerAlert object if successful, NULL if no such ServerAlert exists
	///	for the given server ID and alert ID.</returns>
	///	<exception cref="RimageException">Thrown if the server ID and/or alert ID is invalid.</exception>
	ServerAlert* GetServerAlert(LPCTSTR serverId, LPCTSTR alertId);

	///	<summary>
	///		Removes acknowledged, or not active, ServerAlert objects from Rapid APIs internal lists. 
	///	</summary>
	/// <remarks>
	///		Main reason for calling this method is to free application's memory.
	/// </remarks>
	///	<returns>void</returns>
	void RemoveAcknowledgedServerAlerts();

	///	<summary>
	///		Removes a specific Job from Rapid APIs internal lists. 
	///	</summary>
	/// <remarks>
	///		This method does nothing if the job with the ID does not exist.
	///	</remarks>
	///	<param name="jobId">ID of the Job to remove.</param>
	///	<returns>true if job was removed, false otherwise</returns>
	///	<exception cref="RimageException">Thrown if the job is submitted or in process.</exception>
	bool RemoveJob(LPCTSTR jobId);
	
	///	<summary>
	///		Removes all finished jobs from Rapid APIs internal lists. 
	///	</summary>
	/// <remarks>
	///		This method does not remove jobs that are created but have never been submitted. 
	///	</remarks>
	///	<returns>void</returns>
	void RemoveFinishedJobs();

	///	<summary>
	///		Optionally sets a directory where information about durable jobs is stored.
	///	</summary>
	/// <remarks>
	///		A default directory is used if this method is never called. 
	///	</remarks>
	void SetDurableJobDirectory(LPCTSTR szDurableJobDir);

	///	<summary>
	///		Gets the directory where information about durable jobs is stored.
	///	</summary>
	///	<returns>Full path to the durable job directory.</returns>
	LPCTSTR GetDurableJobDirectory();

	///	<summary>
	///		Recovers all previously in process jobs, for all open connections.
	///	</summary>
	/// <remarks>
	///		This method recovers job statuses for jobs that were in process when the caller application
	///		either shutdown or disconnected. 
	///	</remarks>
	///	<param name="jobIdList">If the iterator is provided, it contains the list of recovered Job IDs</param>
	///	<returns>Total number of jobs recovered for all connections.</returns>
	virtual int RecoverDurableJobs(StringIterator *jobIdList = NULL) = 0;

	///	<summary>
	///		Disconnects from the messaging server this session is connected to.
	///	</summary>
	///	<exception cref="RimageException">Thrown in case of an internal or a network problem.</exception>
	///	<returns>void</returns>
	virtual void Disconnect() = 0;

	///	<summary>
	///		Returns the string form of the specific server related enum values.
	///	</summary>
	///	<param name="enumValue">An enum value related to Server class.</param>
	///	<returns>The corresponding string name of the enum value.</returns>
	///	<exception cref="RimageException">Thrown when the enumValue is out of rangne.</exception>
	static LPCTSTR EnumToString(int enumValue);

	///	<summary>
	///		Setting comments into the XML strings generated by RAPID. If set, the string will be placed
	///		right after the XML start and before the RAPID default comment.
	///	</summary>
	///	<param name="szComment">Comment to add.</param>
	void SetXmlOriginatorComment(LPCTSTR szComment);
			
protected:
	ClientSession(bool bSingleConnSession);

	// For internal use
	static ClientSession *GetCurrSession();
	Rimage::Rapid::Impl::InternClientSession *GetInternSession() ;
	Job* CreateJob(JobType jobType);
private:
	IJobFactory *m_pDefaultJobFactory;
	IJobFactory *m_pUserJobFactory;
	Rimage::Rapid::Impl::InternClientSession *m_pInternSession;
	DWORD m_dwJobIDCounter;

	// Either an instance of SingleConnectionSession or MultpleConnectionSession;
	static ClientSession *gpCurrentClientSession;
	friend class Rimage::Rapid::Impl::ConnectionImpl;
	friend class Rimage::Rapid::Impl::WinSubclasser;
};

}}}