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

namespace PACNET
{
    /// <summary>System Information API</summary>
    public partial class Sys
    {
        //module type const
        /// <summary>Genernal I-8000W module</summary>
        public const int PAC_PARALLEL = 0x80;

        /// <summary>I-8000RW module (R version: Provide PowerOn and Safe value)</summary>
        public const int PAC_PARALLEL_RW = 0x81;

        /// <summary>No module defined</summary>
        public const int PAC_SCAN = 0x40;

        /// <summary>I-8000W module with 32 DI channels</summary>
        public const int PAC_DI32 = 0xE3;

        /// <summary></summary>
        public const int PAC_32BIT = 0x20;

        /// <summary>I-8000W module with 32 DO channels</summary>
        public const int PAC_DO32 = 0xE0;

        /// <summary>I-8000W module with 16 DI channels and 16 DO channels</summary>
        public const int PAC_DI16DO16 = 0xE2;

        /// <summary>I-8000W module with 16 DI channels</summary>
        public const int PAC_DI16 = 0xC3;

        /// <summary>I-8000W module with 16 DO channels</summary>
        public const int PAC_DO16 = 0xC0;

        /// <summary>I-8000W module with 8 DI channels and 8 DO channels</summary>
        public const int PAC_DI8DO8 = 0xC2;

        /// <summary></summary>
        public const int PAC_8K = 8000;



        //1.1. PAC_API bool pac_BackwardCompatible()
        /// <summary>
        /// This function retrieves the PAC running in the backward compatible mode or not.
        /// </summary>
        /// <returns>Return true if the PAC is running in a backward compatible mode, otherwise false.</returns>      
        [DllImport("PACSDK.dll", EntryPoint = "pac_BackwardCompatible")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool BackwardCompatible();

        //1.2. PAC_API void pac_ChangeSlot(BYTE slotNo)
        /// <summary>
        /// This function specifies the slot from one to another.
        /// </summary>
        /// <param name="slotNo">[in]Specifies the slot number.</param>
        [DllImport("PACSDK.dll", EntryPoint = "pac_ChangeSlot")]
        public static extern void ChangeSlot(byte slotNo);

        //1.3. PAC_API void pac_EnableLED(int pin, bool bFlag)
        /// <summary>
        /// This function decides the LED turning on or not.
        /// </summary>
        /// <param name="bFlag">[in] True: On, False:Off</param>
        [DllImport("PACSDK.dll", EntryPoint = "pac_EnableLED")]
        public static extern void EnableLED(bool bFlag);

        /// <summary>
        /// This function decides the LED turning on or not.
        /// </summary>
        /// <param name="pin">[in] 0: L1 LED, 1:L2 LED</param>
        /// <param name="bFlag">[in] True: On, False:Off</param>
        [DllImport("PACSDK.dll", EntryPoint = "pac_EnableLEDs")]
        public static extern void EnableLEDs(int pin, bool bFlag);

        //1.4. PAC_API void pac_GetCPUVersion(LPSTR cpu_version)
        /// <summary>
        /// This function retrieves the CPU version.
        /// </summary>
        /// <param name="cpu_version">[out]Retrieves the CPU version of the PAC.</param>
        [DllImport("PACSDK.dll", EntryPoint = "pac_GetCPUVersion")]
        public static extern void GetCPUVersion(byte[] cpu_version);

        /// <summary>
        /// This function retrieves the CPU version.
        /// </summary>
        /// <returns>Return the CPU version.</returns>   
        public static string GetCPUVersion()
        {
            byte[] result = new byte[128];
            GetCPUVersion(result);
            string CPUVersion = StrConvert.WideString(result);
            return CPUVersion;
        }

        //1.5. PAC_API void pac_GetEbootVersion(LPSTR eboot_version)
        /// <summary>
        /// This function retrieves the eboot version.
        /// </summary>
        /// <param name="eboot_version">[out]Retrieves the Eboot version.</param>
        [DllImport("PACSDK.dll", EntryPoint = "pac_GetEbootVersion")]
        public static extern void GetEbootVersion(byte[] eboot_version);

        /// <summary>
        /// This function retrieves the eboot version.
        /// </summary>
        /// <returns>Return the eboot version.</returns>   
        public static string GetEbootVersion()
        {
            byte[] result = new byte[32];
            GetEbootVersion(result);
            string EbootVersion = StrConvert.WideString(result);

            if (EbootVersion.Length >= 8)
            {
                string temp = EbootVersion.Substring(6, 1);

                if (temp == "0")
                { temp = EbootVersion.Substring(7, 1); }
                else
                { temp = EbootVersion.Substring(6, 2); }

                return EbootVersion.Substring(1, 1) + "." + EbootVersion.Substring(3, 1) + "." + EbootVersion.Substring(5, 1) + "." + temp;
            }
            else
                return "";
        }

        //1.6. PAC_API void pac_GetMacAddress(BYTE LAN, LPSTR MacAddr)
        /// <summary>
        /// This function retrieves the Mac address.
        /// </summary>
        /// <param name="LAN">[in] Specifies the LAN number.</param>
        /// <param name="MacAddr">[out] Retrieves the MAC address of the specified LAN port.</param>
        [DllImport("PACSDK.dll", EntryPoint = "pac_GetMacAddress")]
        public static extern void GetMacAddress(byte LAN, byte[] MacAddr);

        /// <summary>
        /// This function retrieves the Mac address.
        /// </summary>
        /// <param name="LAN">Specifies the LAN number.</param>
        /// <returns>Return the Mac address.</returns>   
        public static string GetMacAddress(byte LAN)
        {
            byte[] result = new byte[32];
            GetMacAddress(LAN, result);
            string MacAddr = StrConvert.WideString(result);

            if (Environment.OSVersion.Version.Major == 5)
            {
                return MacAddr.Substring(0, 2) + "-" + MacAddr.Substring(2, 2) + "-" + MacAddr.Substring(4, 2) + "-" + MacAddr.Substring(6, 2) + "-" + MacAddr.Substring(8, 2) + "-" + MacAddr.Substring(10, 2);
            }
            else
            {
                return MacAddr;
            }
        }

        //1.7. pac_GetMapCOM SDK 沒有

        //1.8. PAC_API int pac_GetModuleName(BYTE slot, LPSTR strName)
        /// <summary>
        /// This function is used to retrieve the name of an 8000 series I/O module, which is plugged
        /// into a specific I/O slot in the Pac system. This function supports the collection of system
        /// hardware configurations.
        /// </summary>
        /// <param name="slot">[in] Specify the slot number where the I/O module is plugged into.</param>
        /// <param name="strName">[out] The pointer to a buffer to receive the name of the I/O module.</param>
        /// <returns>Return 255 if the module is I-8K series module, otherwise, undefined.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "pac_GetModuleName")]
        public static extern int GetModuleName(byte slot, byte[] strName);

        /// <summary>
        /// This function is used to retrieve the name of an 8000 series I/O module, which is plugged
        /// into a specific I/O slot in the Pac system. This function supports the collection of system
        /// hardware configurations.
        /// </summary>
        /// <param name="slot">[in]Specify the slot number where the I/O module is plugged into.</param>
        /// <param name="strName">[out]The pointer to a buffer to receive the name of the I/O module.</param>
        /// <returns>Return 255 if the module is I-8K series module, otherwise, undefined.</returns>   
        public static int GetModuleName(byte slot, ref string strName)
        {
            int iRet;
            byte[] str = new byte[128];
            iRet = GetModuleName(slot, str);
            strName = StrConvert.WideString(str);

            return iRet;
        }

        /// <summary>
        /// This function is used to retrieve the name of an 8000 series I/O module, which is plugged
        /// into a specific I/O slot in the Pac system. This function supports the collection of system
        /// hardware configurations.
        /// </summary>
        /// <param name="slot">[in]Specify the slot number where the I/O module is plugged into.</param>
        /// <returns>Return the name of the I/O module.</returns>   
        public static string GetModuleName(byte slot)
        {
            byte[] str = new byte[128];
            GetModuleName(slot, str);

            return StrConvert.WideString(str);
        }

        //1.9. PAC_API int pac_GetModuleType(BYTE slot)
        /// <summary>
        /// This function is used to retrieve the type of I/O modules.
        /// </summary>
        /// <param name="slot">[in] Specify the slot number where the I/O module is plugged into.</param>  
        [DllImport("PACSDK.dll", EntryPoint = "pac_GetModuleType")]
        public static extern int GetModuleType(int slot);

        //1.10. PAC_API void pac_GetOSVersion(LPSTR os_version)
        /// <summary>
        /// This function retrieves the OS version.
        /// </summary>
        /// <param name="os_version">[out] Retrieves the OS version of the PAC.</param>
        [DllImport("PACSDK.dll", EntryPoint = "pac_GetOSVersion")]
        public static extern void GetOSVersion(byte[] os_version);

        /// <summary>
        /// This function retrieves the OS version.
        /// </summary>
        /// <returns>Return the OS version.</returns>   
        public static string GetOSVersion()
        {
            byte[] result = new byte[32];
            GetOSVersion(result);
            string OSVersion = StrConvert.WideString(result);

            if (Environment.OSVersion.Version.Major == 5)
            {
                return OSVersion.Substring(1, 1) + "." + OSVersion.Substring(3, 1) + "." + OSVersion.Substring(5, 1) + "." + OSVersion.Substring(7, 1);
            }
            else
            {
                return OSVersion;
            }
        }

        //1.11. PAC_API int pac_GetRotaryID()
        /// <summary>
        /// This function retrieves the rotary switch ID.
        /// </summary>
        /// <returns>Return the position of the rotary switch.</returns>   
        [DllImport("PACSDK.dll", EntryPoint = "pac_GetRotaryID")]
        public static extern int GetRotaryID();

        //1.12. PAC_API void pac_GetSerialNumber(LPSTR SerialNumber)
        /// <summary>
        /// This function retrieves the serial number.
        /// </summary>
        /// <param name="SerialNumber">[out] Retrieves the serial number of the PAC.</param>
        [DllImport("PACSDK.dll", EntryPoint = "pac_GetSerialNumber")]
        public static extern int GetSerialNumber(byte[] SerialNumber);

        /// <summary>
        /// This function retrieves the serial number.
        /// </summary>
        /// <returns>Return the serial number.</returns>   
        public static string GetSerialNumber()
        {
            byte[] result = new byte[32];
            GetSerialNumber(result);
            string SN = StrConvert.WideString(result);
            return string.Format("{0}-{1}-{2}-{3}-{4}-{5}-{6}-{7}",
                SN.Substring(0, 2),
                SN.Substring(2, 2),
                SN.Substring(4, 2),
                SN.Substring(6, 2),
                SN.Substring(8, 2),
                SN.Substring(10, 2),
                SN.Substring(12, 2),
                SN.Substring(14, 2));
        }

        //1.13. pac_GetPacNetVersion()
        /// <summary>
        /// This function retrieves the version of the PacNet.dll.
        /// </summary>
        /// <returns>Return the version of the PacNet.dll.</returns>    
        public static string GetPacNetVersion()
        {
            return Assembly.GetExecutingAssembly().GetName().Version.ToString();//"1.2.1.1";
        }

        //1.14. PAC_API void pac_GetSDKVersion(LPSTR sdk_version)
        /// <summary>
        /// This function retrieves the SDK version.
        /// </summary>
        /// <param name="sdk_version">[out] Retrieves the version of the PacSDK.</param>   
        [DllImport("PACSDK.dll", EntryPoint = "pac_GetSDKVersion")]
        public static extern int GetSDKVersion(byte[] sdk_version);

        /// <summary>
        /// This function retrieves the SDK version.
        /// </summary>
        /// <returns>Return the SDK version.</returns> 
        public static string GetPacSDKVersion()
        {
            byte[] result = new byte[32];
            GetSDKVersion(result);
            string SDKVersion = StrConvert.WideString(result);
            return SDKVersion;
        }

        //1.15. PAC_API void pac_Reboot(void)
        /// <summary>
        /// This function reboots the device.
        /// </summary>
        [DllImport("PACSDK.dll", EntryPoint = "pac_Reboot")]
        public static extern void Reboot();

        ///////////////////////////////////////////////////////////////////////
        //
        // from Xpac
        //
        ///////////////////////////////////////////////////////////////////////

        //1.6. PAC_API bool pac_CheckSDKVersion(DWORD version)
        /// <summary>
        /// This function specifies the application not access the XPacSDK.dll which is wrong version.
        /// </summary>
        /// <param name="version">[in] Specifies SDK version.</param>   
        /// <returns>Return TRUE, if the version is correctly. Otherwise, return false.</returns> 
        [DllImport("PACSDK.dll", EntryPoint = "pac_CheckSDKVersion")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool CheckSDKVersion(uint version);

        //1.7. PAC_API bool pac_ModuleExists(HANDLE hPort, int slot)
        /// <summary>
        /// This function specifies the IO module whether exist or not, no matter the module is local or remote.
        /// </summary>
        /// <param name="hPort">[in] The serial port HANDLE opened by uart_Open().
        /// It your IO module is located at local, this Parameter should be 0.</param>   
        /// <param name="slot">[in] The slot in which module is to check exists or not.
        /// If the IO module is remote, please input the module’s ID.</param>   
        /// <returns>Return TRUE, if the module exists. Otherwise, return false.</returns> 
        [DllImport("PACSDK.dll", EntryPoint = "pac_ModuleExists")]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool ModuleExists(IntPtr hPort, byte slot);

        ///////////////////////////////////////////////////////////////////////
        //
        // Undocumented
        //
        ///////////////////////////////////////////////////////////////////////

        //1.?. PAC_API int  pac_GetModuleVersion(BYTE slot, LPSTR strName);
        /// <summary>
        /// </summary>
        /// <param name="slot"></param>   
        /// <param name="strName"></param>   
        /// <returns></returns> 
        [DllImport("PACSDK.dll", EntryPoint = "pac_GetModuleVersion")]
        public static extern int GetModuleVersion(int slot, byte[] strName);
    }
}