using System;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;

namespace PACNET
{
    /// <summary>UART API</summary>
    public class UART
    {
        /// <summary>IN_DATA</summary>
        public const int IN_DATA = 0;

        /// <summary>OUT_DATA</summary>
        public const int OUT_DATA = 1;


        /// <summary>CTS</summary>
        public const int CTS = 0;

        /// <summary>DSR</summary>
        public const int DSR = 1;

        /// <summary>RI</summary>
        public const int RI = 2;

        /// <summary>CD</summary>
        public const int CD = 3;


        /// <summary>CTO_TIMEOUT_ALL</summary>
        public const int CTO_TIMEOUT_ALL = 0;

        /// <summary>CTO_READ_RETRY_TIMEOUT</summary>
        public const int CTO_READ_RETRY_TIMEOUT = 1;

        /// <summary>CTO_READ_TOTAL_TIMEOUT</summary>
        public const int CTO_READ_TOTAL_TIMEOUT = 2;

        /// <summary>CTO_WRITE_TOTAL_TIMEOUT</summary>
        public const int CTO_WRITE_TOTAL_TIMEOUT = 3;


        //8.1. PAC_API bool uart_BinRecv(HANDLE hPort, LPSTR buf, DWORD in_Len)
        /// <summary>
        /// This function is applied to receive the fix length response.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port.</param>
        /// <param name="buf">[out] A pointer to a buffer that receives the data.</param>
        /// <param name="in_Len">[in] The length of result string.</param>
        /// <returns>1: indicates success, 0: indicates failure.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_BinRecv")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool BinRecv(IntPtr hPort, byte[] buf, uint in_Len);

        //8.2. PAC_API bool uart_BinSend(HANDLE hPort, LPCSTR buf, DWORD in_Len)
        /// <summary>
        /// Send out the command string by fix length, which is controlled by the Parameters “in_Len”.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port.</param>
        /// <param name="buf">[in] A pointer to a buffer that send the data.</param>
        /// <param name="in_Len">[in] The length of result string.</param>
        /// <returns>1: indicates success, 0: indicates failure.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_BinSend")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool BinSend(IntPtr hPort, byte[] buf, uint in_Len);

        //8.3. PAC_API bool uart_BinSendCmd(HANDLE hPort, LPCSTR ByteCmd, DWORD in_Len, LPSTR ByteResult, DWORD out_Len)
        /// <summary>
        /// This function is used to Send binary command and receive binary data with the fixed length.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM.</param>
        /// <param name="ByteCmd">[in] A pointer to a command.</param>
        /// <param name="in_Len">[in] The length of command string.</param>
        /// <param name="ByteResult">[out] A pointer to a buffer that receives the data.</param>
        /// <param name="out_Len">[in] The length of result string.</param>
        /// <returns>1: indicates success, 0: indicates failure.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_BinSendCmd")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool BinSendCmd(IntPtr hPort, byte[] ByteCmd, uint in_Len, byte[] ByteResult, uint out_Len);

        //8.4. PAC_API bool uart_Close(HANDLE hPort)
        /// <summary>
        /// This function closes the COM port which has been opened.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port to close.</param>
        /// <returns>1: indicates success, 0: indicates failure.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_Close")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool Close(IntPtr hPort);

        //8.5. PAC_API void uart_EnableCheckSum(HANDLE hPort, bool bEnable)  // Disable by default
        /// <summary>
        /// This function turns on the check sum or not.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port to close.</param>
        /// <param name="bEnable">[in] Decide the check sum turning on or not. Default is disabling.</param>
        [DllImport("PACSDK.dll", EntryPoint = "uart_EnableCheckSum")]
        public static extern void EnableCheckSum(IntPtr hPort, bool bEnable);

        //8.6. PAC_API DWORD uart_GetDataSize(HANDLE hPort, int data_type)
        /// <summary>
        /// This function retrieves the number of bytes received by the serial provider but not yet read
        /// by a uart_Recv operation, or of user data remaining to transmit for write operations.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port.</param>
        /// <param name="data_type">[in] A value specifies to retrieve in or out buffer.
        /// This Parameters can be following values, 0: IN_DATA, 1: #define OUT_DATA</param>
        /// <returns>The number of bytes in/out buffer but not yet read/write.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_GetDataSize")]
        public static extern uint GetDataSize(IntPtr hPort, int data_type);

        //8.7. PAC_API bool uart_GetLineStatus(HANDLE hPort, int pin)
        /// <summary>
        /// This function retrieves the modem control-register values.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port.</param>
        /// <param name="pin">[in] A variable specifies state of a pin of the COM port.
        /// This Parameters can be following values, 0: CTS, 1: DSR, 2: RI 3:CD</param>
        /// <returns>TRUE indicates the pin’s state is ON. 0 indicates OFF.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_GetLineStatus")]
        public static extern uint GetLineStatus(IntPtr hPort, int pin);

        //8.8. PAC_API HANDLE uart_Open(LPCSTR ConnectionString) // "COM0:,115200,8,N,1"
        [DllImport("PACSDK.dll", EntryPoint = "uart_Open")]
        static extern IntPtr _uart_Open(byte[] ConnectionString);
        /// <summary>
        /// This function opens the COM port and specifies the baud rate, parity bits, data bits, and stop bits.
        /// </summary>
        /// <param name="ConnectionString">[in] Specifies the COM port, baud rate, parity bits, data bits, and stop bits.</param>
        /// <returns>TRUE indicates the pin’s state is ON. 0 indicates OFF.</returns>   
        public static IntPtr Open(string ConnectionString)
        {
            return _uart_Open(MISC.AnsiString(ConnectionString));
        }

        //8.9. PAC_API bool uart_Recv(HANDLE hPort, LPSTR buf)
        /// <summary>
        /// This function retrieves data through the COM port which have been opened.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port.</param>
        /// <param name="buf">[out] A pointer to a buffer that receives the data.</param>
        /// <returns>1: indicates success. 0: indicates failure.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_Recv")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool Recv(IntPtr hPort, [In, Out] byte[] buf);

        //8.10. PAC_API bool uart_Send(HANDLE hPort, LPCSTR buf)
        /// <summary>
        /// This function sends data through the COM port which have been opened.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port.</param>
        /// <param name="buf">[in] A pointer to a buffer that send the data, 2048 bytes maximum.</param>
        /// <returns>1: indicates success. 0: indicates failure.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_Send")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool Send(IntPtr hPort, byte[] buf);

        //8.11. PAC_API bool uart_SendCmd(HANDLE hPort, LPCSTR cmd, LPSTR szResult)
        /// <summary>
        /// This function sends commands through the COM port which have been opened.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM.</param>
        /// <param name="cmd">[in] A pointer to a command.</param>
        /// <param name="szResult">[out] A pointer to a buffer that receives the data.</param>
        /// <returns>1: indicates success. 0: indicates failure.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_SendCmd")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool SendCmd(IntPtr hPort, byte[] cmd, [In, Out] byte[] szResult);

        //8.12. PAC_API void uart_SetTerminator(HANDLE hPort, LPCSTR szTerm) // CR by default
        /// <summary>
        /// This function sets the terminate characters.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port.</param>
        /// <param name="szTerm">[in] Pointer the terminate characters. Default is CR (0x0D).</param> 
        [DllImport("PACSDK.dll", EntryPoint = "uart_SetTerminator")]
        public static extern void SetTerminator(IntPtr hPort, byte[] szTerm);

        //8.13. PAC_API void uart_SetTimeOut(HANDLE hPort, DWORD msec, int ctoType)
        /// <summary>
        /// This function sets the time out timer.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port.</param>
        /// <param name="msec">[in] millisecond to the timer.</param>
        /// <param name="ctoType">[in] Specifies the time out timer type as following:
        /// 0: CTO_TIMEOUT_ALL, 1: CTO_READ_RETRY_TIMEOUT, 2: CTO_READ_TOTAL_TIMEOUT, 3: CTO_WRITE_TOTAL_TIMEOUT</param>
        [DllImport("PACSDK.dll", EntryPoint = "uart_SetTimeOut")]
        public static extern void SetTimeOut(IntPtr hPort, uint msec, int ctoType);

        //PAC_API boo uart_RecvExt(HANDLE hPort, LPSTR buf, DWORD in_Len);
        /// <summary>
        /// This function is applied to receive the fix length response.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port.</param>
        /// <param name="buf">[out] A pointer to a buffer that receives the data.</param>
        /// <param name="in_Len">[in] The length of result string.</param>
        /// <returns>1: indicates success, 0: indicates failure.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_RecvExt")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool RecvExt(IntPtr hPort, byte[] buf, uint in_Len);

        //PAC_API bool uart_SendExt(HANDLE hPort, LPCSTR buf, DWORD out_Len);
        /// <summary>
        /// Send out the command string by fix length, which is controlled by the Parameters “in_Len”.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM port.</param>
        /// <param name="buf">[in] A pointer to a buffer that send the data.</param>
        /// <param name="out_Len">[in] The length of result string.</param>
        /// <returns>1: indicates success, 0: indicates failure.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_SendExt")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool SendExt(IntPtr hPort, byte[] buf, uint out_Len);

        //PAC_API bool uart_SendCmdExt(HANDLE hPort, LPCSTR cmd, DWORD out_Len, LPSTR szResult, DWORD in_Len);  
        /// <summary>
        /// This function is used to Send string command and receive string data with the fixed length.
        /// </summary>
        /// <param name="hPort">[in] Handle to the open COM.</param>
        /// <param name="ByteCmd">[in] A pointer to a command.</param>
        /// <param name="in_Len">[in] The length of command string.</param>
        /// <param name="ByteResult">[out] A pointer to a buffer that receives the data.</param>
        /// <param name="out_Len">[in] The length of result string.</param>
        /// <returns>1: indicates success, 0: indicates failure.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "uart_SendCmdExt")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool SendCmdExt(IntPtr hPort, byte[] ByteCmd, uint in_Len, byte[] ByteResult, uint out_Len);
    }
}