///////////////////////////////////////////////////////////////////////////////////////////////
///	\file	SangomaPort.h
///	\brief	This file contains the declaration of the SangomaPort class
///////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _SANGOMA_PORT_H
#define _SANGOMA_PORT_H

#ifdef WIN32
#define __WINDOWS__
#include <windows.h>
#endif

#include <string>
#include "PortBuffer.h"

// Forward declarations to limit the third-party Sangoma includes to the .cpp file only.
struct sangoma_wait_obj;
typedef sangoma_wait_obj sangoma_wait_obj_t;
class sangoma_interface;
#ifdef LINUX
typedef pthread_mutex_t CRITICAL_SECTION;
#endif
struct wanpipe_api;
typedef wanpipe_api wanpipe_api_t;

namespace Sangoma {

// Read/Write error codes
const int ERROR_NO_DATA_AVAILABLE = -1;						///< Error code indicating that a SangomaPort::Read was attempted when no data was available (indicates a possible abuse of the API by polling for data instead of waiting for the DataAvailableEvent)
const int ERROR_INVALID_DESTINATION_BUFFER = -2;			///< Error code indicating that the destination buffer provided to SangomaPort::Read was NULL
const int ERROR_INVALID_SOURCE_BUFFER = -3;					///< Error code indicating that the source buffer provided to SangomaPort::Write was NULL
const int ERROR_NO_DATA_WRITTEN = -4;						///< Error code indicating that the SangomaPort::Write command failed
const int ERROR_PORT_NOT_OPEN = -5;							///< Error code indicating that the Read or Write command failed because the port has not been opened.  Call SangomaPort::Open() successfully before attempting to Read or Write.
const int ERROR_INVALID_DESTINATION_BUFFER_TOO_SMALL = -6;	///< Error code indicating that the destination buffer provided to SangomaPort::Read was to small to contain a full buffer's worth of data (configuration error)
const int ERROR_INVALID_READ_REQUEST = -7;					///< Error code indicating that the input to SangomaPort::Read was invalid
/// \todo Add more detailed read/write failure codes as available from the API (more detail is better)
const int ERROR_DEVICE_IOCTL = -8;							///< Error code indicating that DeviceIoControl() for API Device Driver failed. Check '/System32/drivers/wanpipelog.txt' messages log for details.
const int ERROR_INVALID_TX_DATA_LENGTH = -8;				///< Error code indicating that SangomaPort::Write failed because user data was too long.


const std::string NO_ERROR_OCCURRED = "";					///< String indicating that no error occurred on the last operation (returned by GetLastError() when the last operation was successful)
const unsigned int MAX_SANGOMA_BUFFER_SIZE = 8188;			///< Maximum Sangoma buffer size in bytes
const unsigned int ALARM_WAIT_TIME_MS = 30000;				///< The number of milliseconds that the Sangoma API must wait in order to be able to reliably report the absence of alarms.
															///		If GetAlarms() is called before this amount of time has elapsed after setting a configuration, the card will always
															///		report no alarms, giving a false positive that we have found synchronization.

///////////////////////////////////////////////////////////////////////////////////////////////
///	\enum	E1OrT1
///	\brief	Enumeration indicating whether a port is in E1 or T1 mode
///////////////////////////////////////////////////////////////////////////////////////////////
enum E1OrT1 {
	E1=32,			///< Indicates that the port is configured as an E1 port
	T1=24			///< Indicates that the port is configured as a T1 port
};

///////////////////////////////////////////////////////////////////////////////////////////////
///	\enum	FramingType
///	\brief	Enumeration indicating the framing type and signaling of the port
///////////////////////////////////////////////////////////////////////////////////////////////

enum FramingType {
	//DAVIDR: i added the UNFRAMED E1 types
	E1_CCS_UNFRAMED,		///< Indicates that Common Channel Signalling (CCS) with Unframed E1, all 32 timeslots available for the E1 port
	E1_CAS_UNFRAMED,		///< Indicates that Channel Associated Signaling (CAS) with Unframed E1, all 32 timeslots available for the E1 port

	E1_CAS_CRC4_ON,			///< Indicates that Channel Associated Signaling (CAS) with CRC4 is the framing type for the E1 port
	E1_CAS_CRC4_OFF,		///< Indicates that Channel Associated Signaling (CAS) with no CRC4 is the framing type for the E1 port
	E1_CCS_CRC4_ON,			///< Indicates that Common Channel Signalling (CCS) with CRC4 is the framing type for the E1 port
	E1_CCS_CRC4_OFF,		///< Indicates that Common Channel Signalling (CCS) with no CRC4 is the framing type for the E1 port

	T1_EXTENDED_SUPERFRAME,	///< Indicates that Extended Superframe (ESF, also called D5 framing) is the framing type for the T1 port
	T1_SUPERFRAME			///< Indicates that Superframe (also called D4 or D3/D4 framing) is the framing type for the T1 port
};

#define DECODE_FRAMING(framing)\
		(framing == E1_CCS_UNFRAMED)? "E1_CCS_UNFRAMED" : \
		(framing == E1_CAS_UNFRAMED)? "E1_CAS_UNFRAMED" : \
		(framing == E1_CAS_CRC4_ON) ? "E1_CAS_CRC4_ON" : \
		(framing == E1_CAS_CRC4_OFF)? "E1_CAS_CRC4_OFF" : \
		(framing == E1_CCS_CRC4_ON) ? "E1_CCS_CRC4_ON" : \
		(framing == E1_CCS_CRC4_OFF)? "E1_CCS_CRC4_OFF" : \
		(framing == T1_EXTENDED_SUPERFRAME) ? "T1_EXTENDED_SUPERFRAME" : \
		(framing == T1_SUPERFRAME)	? "T1_SUPERFRAME" : "???"

#define DECODE_CARD_TYPE(type) \
		(type == A104)? "A104" : \
		(type == A108)? "A108" : \
		(type == A116)? "A116" : \
		(type == T116)? "T116" : "Invalid Card" 
		

//DAVIDR: On E1 line Sangoma card provides access to timeslot 0 ONLY if Framing is "Unframed E1".

///////////////////////////////////////////////////////////////////////////////////////////////
///	\enum	LineCoding
///	\brief	Enumeration indicating whether line coding is on or off for the port
///////////////////////////////////////////////////////////////////////////////////////////////
enum LineCoding {
	OFF,		///< Indicates that line coding is off (meaning set to the default AMI value)
	ON			///< Indicates that line coding is on (meaning B8ZS for T1, and HDB3 for E1)
};

/**********************************************************
DAVIDR: Receiver Sensitivity (Max Cable Loss Allowed) (dB)
The user will have the following option to choose:
1. HI IMPEDANCE mode:
30 dB
22.5 dB
17.5 dB
12 dB

Depending on selection, use the following values:
300
225
175
120

2. NORMAL mode:
12 dB
18 dB
30 dB
36 dB (for T1)
43 dB (for E1)

Depending on selection, use the following values:
120
180
300
360
430
**********************************************************/
enum MAX_CABLE_LOSS{
	MCLV_43_0dB=430,
	MCLV_36_0dB=360,
	MCLV_30_0dB=300,
	MCLV_22_5dB=225,
	MCLV_18_0dB=180,
	MCLV_17_5dB=175,
	MCLV_12_0dB=120
};

typedef enum SNG_API_MODE{
	SNG_SPAN_MODE=0,
	SNG_CHAN_MODE=1,
	SNG_DATA_MODE=2
} sng_api_mode_t;

///////////////////////////////////////////////////////////////////////////////////////////////
///	\struct	Configuration
///	\brief	Structure containing all settings necessary to configure a Sangoma port
///////////////////////////////////////////////////////////////////////////////////////////////
struct Configuration {
	Sangoma::E1OrT1  E1OrT1;  ///< Configures the port as either E1 or T1
	FramingType  Framing;  ///< Framing type and signalling of the E1/T1 port
	Sangoma::LineCoding  LineCoding;  ///< Indicates whether line coding is ON or OFF
	bool  HighImpedanceMode;  ///< true to indicate High Impedance mode is to be enabled, false to disable it
	MAX_CABLE_LOSS  MaxCableLoss;  ///< If High Impedance is true, indicates value of external resistor.
	bool  TxTristateMode;  ///< If true, indicates transmitter is disabled on T1/E1 level.
	bool  Master;		///< If true, configure for master clock
	int   dchan;        ///< Integer value of a dchan 
	int   chunk_ms;     ///< Integer value of ms chunk size default 20 (160bytes per timeslot)
	sng_api_mode_t api_mode;
	int   dchan_seven_bit;
	int   dchan_mtp1_filter;
	
    ///////////////////////////////////////////////////////////////////////////////////////////////
    ///	\fn		Configuration::Configuration()
    ///	\brief	Constructor (for the Configuration structure)
    ///	\author	J. Markwordt
    ///	\date	10/04/2007
    ///////////////////////////////////////////////////////////////////////////////////////////////
    Configuration():
        E1OrT1(E1),
	    Framing(E1_CAS_CRC4_ON),
	    LineCoding(OFF),
	    HighImpedanceMode(true),
	    TxTristateMode(false),
        Master(false),
		dchan(0)
    {}
};

///////////////////////////////////////////////////////////////////////////////////////////////
///	\struct	Statistics
///	\brief	Structure containing all statistics related to a Sangoma port
///////////////////////////////////////////////////////////////////////////////////////////////
struct Statistics {
	// The following time values are to be calculated using the time() function found in time.h.  This
	// is standard ANSI C and returns the current time as the number of seconds elapsed since midnight
	// on January 1, 1970.  Operations involving elapsed time can then be done by subtracting from
	// current time (or some other instant) and converting to hours, minutes and seconds
	// The function struct tm * localtime(const time_t * timer); will convert the time to a tm structure
	// that is broken into date and time fields

	// Statistics maintained in software by the SangomaPort class
	time_t	TimeLastOpened;					///< System time of the last time this port was opened
	time_t	TimeLastClosed;					///< System time of the last time this port was closed
	time_t	TimeLastFoundSync;				///< System time of the last time this port found sync with a valid configuration
	time_t	TimeLastLostSync;				///< System time of the last time this port lost sync when already in sync

	unsigned int OpenCount;			///< Count of the number of times the port was opened (i.e. number of times SangomaPort::Open() returned successfully)
	unsigned int CloseCount;		///< Count of the number of times the port was closed (i.e. number of times SangomaPort::Close() returned successfully)
	unsigned int FoundSyncCount;	///< Count of the number of times synchronization was found on the port (i.e. number of times sync was found when the port was opened)
	unsigned int LostSyncCount;		///< Count of the number of times synchronization was lost on the port (i.e. number of times the LineDisconnected event was raised, since both indicate a loss of sync on the line)

	// Statistics maintained in hardware, a command will have to be sent to the port to retrieve this data
	unsigned int	BytesReceived;			///< Number of bytes received on this port
	unsigned int	BytesSent;				///< Number of bytes transmitted from this port
	unsigned int	Errors;	   	 			///< Number of bytes transmitted from this port

	///////////////////////////////////////////////////////////////////////////////////////////////
    ///	\fn		Statistics::Statistics()
    ///	\brief	Constructor (for the Statistics structure)
    ///	\author	J. Markwordt
    ///	\date	10/04/2007
    ///////////////////////////////////////////////////////////////////////////////////////////////
    Statistics():
     	TimeLastOpened(0),
	    TimeLastClosed(0),
	    TimeLastFoundSync(0),
	    TimeLastLostSync(0),
	    OpenCount(0),
	    CloseCount(0),
	    FoundSyncCount(0),
	    LostSyncCount(0),
	    BytesReceived(0),
	    BytesSent(0),
        Errors(0)
    {}
};

///////////////////////////////////////////////////////////////////////////////////////////////
///	\struct	Alarms
///	\brief	Structure containing a series off boolean flags to indicate the presence of Sangoma
///			hardware alarms.  If true, indicates that the given alarm is present, if false indicates
///			that the alarm is not present.
///////////////////////////////////////////////////////////////////////////////////////////////
struct Alarms {
	bool LossOfSignal;					///< Indicates that the Loss of Signal (ALOSV) alarm is present if true
	bool ReceiveLossOfSignal;			///< Indicates that the Receive Loss of Signal (LOS) alarm is present if true
	bool AlternateLossOfSignalStatus;	///< Indicates that the Alternate loss of Signal Status (ALTLOS) alarm is present if true
	bool OutOfFrame;					///< Indicates that the Out of Frame (OOF) alarm is present if true
	bool Red;							///< Indicates that the Telco Red Alarm condition (RED) is present if true
	bool AlarmIndicationSignal;			///< Indicates that the Alarm Indication Signal (AIS) is present if true
	bool LossOfSignalingMultiframe;		///< Indicates that the Loss of Signaling Multiframe (OOSMFV) alarm is present if true
	bool LossOfCrcMultiframe;			///< Indicates that the Loss of CRC Multiframe (OOCMFV) alarm is present if true
	bool OutOfOfflineFrame;				///< Indicates that the Out of Off-Line Frame (OOOFV) alarm is present if true
	bool ReceiveLossOfSignalV;			///< Indicates that the Receive Loss of Signal (RAIV) alarm is present if true
	bool Yellow;						///< Indicates that the Receive Telco Yellow Alarm (YEL) is present if true

	Alarms();							///< Constructor
	Alarms(bool value)					///< Constructor
	{
		LossOfSignal = value;
		ReceiveLossOfSignal = value;
		AlternateLossOfSignalStatus = value;
		OutOfFrame = value;
		Red = value;
		AlarmIndicationSignal = value;
		LossOfSignalingMultiframe = value;
		LossOfCrcMultiframe = value;
		OutOfOfflineFrame = value;
		ReceiveLossOfSignalV = value;
		Yellow = value;
	}
};

///////////////////////////////////////////////////////////////////////////////////////////////
/// \struct	DriverVersion
///	\brief	Structure containing the driver version number
///////////////////////////////////////////////////////////////////////////////////////////////
struct DriverVersion {
	unsigned int Major;		///< The major version number of the driver (i.e. the 1 in 1.2.3.4)
	unsigned int Minor;		///< The minor version number of the driver (i.e. the 2 in 1.2.3.4)
	unsigned int Build;		///< The build version number of the driver (i.e. the 3 in 1.2.3.4)
	unsigned int Revision;	///< The revision version number of the driver (i.e. the 4 in 1.2.3.4)

	DriverVersion();		///< Constructor

    std::string ToString();	// G3 specific change
};

///////////////////////////////////////////////////////////////////////////////////////////////
///	\enum	PortEventType
///	\brief	Enumeration indicating the type of event that that triggered a call to the PortEventHandler
///////////////////////////////////////////////////////////////////////////////////////////////
enum PortEventType {
	Unsignalled,		///< Default value, indicates that the event has not been signalled (should not be seen in actual events that are triggered)
	ReadDataAvailable,	///< Indicates that the read buffer is full (SangomaPort::Read() can be called to service the buffer)
	LineConnected,		///< Indicates that a port that was unoccupied has had an E1/T1 line plugged in
	LineDisconnected,	///< Indicates that a port that had an E1/T1 line plugged in has had the line disconnected
	TransmitBufferAvailable ///< Indicated that a port has at least one free Transmit buffer.
};

///////////////////////////////////////////////////////////////////////////////////////////////
///	\struct	PortEvent
///	\brief	Structure representing an event that occurred on a port within the card
///////////////////////////////////////////////////////////////////////////////////////////////
struct PortEvent {
	PortEventType EventType;			///< Status code indicating the type of event that occured
	sangoma_wait_obj_t *EventHandle;	///< Handle to the Sangoma waitable object

	PortEvent();				///< Constructor
};

///////////////////////////////////////////////////////////////////////////////////////////////
///	\struct BufferSettings
///	\brief	Structure containing settings for configuring the host memory buffers assigned to a
///			Sangoma port.  Data is transferred to host memory via DMA, and an event is set to indicate
///			that the buffers are full and read to be read, so it is inportant to configure the host
///			memory buffers to the needs of your application.  Sangoma defines a MRU/MTU of 8188 bytes
///			(the maximum size of an HDLC frame) and assigns buffers of this size to a port (although
///			data is always read or written in even frames of 8184 bytes for T1 and 8160 for E1
///			(32 timeslots).
///
///			The size of the buffers will be configurable in multiples of this 8188 bytes enforced
///			by hardware, such that 8188 * BufferMultiplierFactor = BufferSize (i.e. a BufferMultiplierFactor
///			of 4 will result in BufferSize = 4 * 8188 = 32752 byes).
///
///			Multiple buffers are assigned for transmit and receiving to queue a certain amount of
///			data.  These are configured by setting NumberOfBuffersPerPort.  If you intend to only
///			use a SangomaPort for either receive or transmit, the NumberOfBuffersPerPort for that
///			set of buffers can be set to 0 (SangomaPort also has special constructors which are
///			for receive-only or transmit-only ports).
///////////////////////////////////////////////////////////////////////////////////////////////
struct BufferSettings {
	unsigned int BufferMultiplierFactor;	///< Number to multiply the MAX_SANGOMA_BUFFER_SIZE by in order to get the size of the buffers allocated in host memory
	unsigned int NumberOfBuffersPerPort;	///< Number of buffers in host memory that will be dedicated to with receiving or transmitting data on this port.

    const static unsigned int MAXIMUM_BUFFER_MULTIPLIER_FACTOR;
    const static unsigned int MINIMUM_BUFFER_MULTIPLIER_FACTOR;
    const static unsigned int MINIMUM_NUMBER_OF_BUFFERS_PER_API_INTERFACE;

    // G3 specific change start
    /// \fn     BufferSettings::BufferSettings()
    /// \brief  Constructor to set the members to default values
    BufferSettings()
    {
        Reset();
    }

    /// \fn     BufferSettings::Reset()
    /// \brief  Set the members to default values
    void Reset()
    {
        BufferMultiplierFactor = 0;
        NumberOfBuffersPerPort = 0;
    }
    // G3 specific change end
};

///////////////////////////////////////////////////////////////////////////////////////////////
///	\class	SangomaPort
///	\brief	This class encapsulates the functionality of a physical Sangoma port found on the
///			A104 and A108 card models.
///	\author	J. Markwordt
///	\date	10/03/2007
///////////////////////////////////////////////////////////////////////////////////////////////
class SangomaPort {
public:
	SangomaPort(
        const unsigned int card_number,
        const unsigned int port_number,
		const BufferSettings& ReceiveBufferSettings,
		const BufferSettings& TransmitBufferSettings);

	~SangomaPort();

	bool Open(const Configuration& configuration);
	bool Close();

	int Read(unsigned int event_flag);				///< Reads Rx data or an Event and places them in the ReceiveBuffer.
													///< Returns reason for wait object being signaled

	unsigned char *GetRxDataBuffer();
	unsigned int GetRxDataLength();

	int Write(unsigned char* p_source_buffer, const unsigned int bytes_to_write);	///< Writes the specified number of bytes from the source buffer to the port

    bool GetSynchronizationStatus();

    unsigned int GetCardNumber() const {return CardNumber;}
	unsigned int GetPortNumber() const;				///< Returns this port's number

	bool GetConfiguration(Configuration& current_configuration);

    PortEvent GetEvent() const;						///< Return the PortEvent associated with this port
	bool GetIsOpen();							///< Return true if this port is currently open, false otherwise

    DriverVersion GetDriverVersion(); ///< Returns this port's driver version number
	Statistics GetStatistics();						///< Get the statistics for this port
	void ClearStatistics();							///< Clear the statistics for this port
	void FlushBuffers();							///< Clear the statistics for this port

	Alarms GetAlarms();								///< Retrieves the alarms from the hardware for this port

    bool GetReceiverLevelInDb(float& receiver_level_in_db);

	std::string GetLastError() const;				///< Returns a description of the last error that occurred (NO_ERROR_OCCURRED if the last command was successful)

	PortBuffer *pReceiveBuffer; ///< Buffers allocated to receive data for this port
	PortBuffer *pTransmitBuffer; ///< Buffers allocated to transmit data for this port

	unsigned int GetUnmappedPortNumber();

	int SetAndOpenTxFile(const char *szTxFileName);		///< Open a file which will be continuesly transmitted

    int GetTransmitMtu() { return TxMtu; } ///< Provides the chunk size to be used each time data is written to the port.  This changes based on the frame type.
	int WriteChunkOfTxFile();						///< Transmit a chunk of the TxFile

	int LineLoopbackEnable();	///< Enable line loopback for testing. All transmitted data will be also received locally. Requires the Port to be in Master clock mode.
	int LineLoopbackDisable();	///< Disable line loopback which was enabled by SangomaPort::LineLoopbackEnable()

	unsigned int RxDiscardCounter;				///< Number of rx buffers to discard after LineConnected event (the buffers may contain idle data).
	unsigned int RxCount;						///< Number of rx buffers to discard after LineConnected event (the buffers may contain idle data).
	unsigned int SyncCount;						///< Number of rx buffers to discard after LineConnected event (the buffers may contain idle data).
	unsigned int RxLength;						///< Number of rx buffers to discard after LineConnected event (the buffers may contain idle data).
 	unsigned int next_framing_type;
	time_t rx_pkt_timeout;

private:
	// Copy constructor and assigment operator are made private
	// and left unimplemented to ensure that the SangomaPort object cannot be copied
	SangomaPort(const SangomaPort& port);
	SangomaPort& operator=(const SangomaPort& rhs);

	unsigned int CardNumber;						///< The number of the SangomaCard that this port is associated with (zero-indexed)
	unsigned int PortNumber;						///< The number assigned to this port (zero-indexed)
	PortEvent Event;								///< Event used to trigger port events with
	bool IsOpen;									///< true if this port is currently open, false otherwise
	Configuration CurrentConfiguration;				///< The current configuration of this port
	Statistics PortStatistics;						///< Statistics related to this port (made member because some are maintained by the class, some are maintained by the hardware)

	std::string LastError;							///< String description of the last error that occurred (should be set if an error occurs in any SangomaPort member functions, or NO_ERROR_OCCURRED if successful)

	BufferSettings ReceiveBufferSettings; ///< These are the settings for the buffer that holds the data when it is received.
    BufferSettings TransmitBufferSettings; ///< These are the settings for the buffer that holds the data that is to be transmitted.

	sangoma_interface *pSangomaInterface;

	CRITICAL_SECTION cs_CriticalSection;
	void EnterPortCriticalSection();
	void LeavePortCriticalSection();
	int TryEnterPortCriticalSection();
	int SetPortConfiguration(const Configuration & config);

	/*! API header for rx data */
	wp_api_hdr_t	*rxhdr;

	/*! API header for tx data */
	wp_api_hdr_t	*txhdr;

	/*! API command structure used to execute API commands. This command structure is used with libsangoma library */
	wanpipe_api_t	*wp_api;

	FILE	*pTxFile;
	int		TxMtu;
};

}// namespace Sangoma

#endif //_SANGOMA_PORT_H