//-----------------------------------------------------------------------
// <copyright file="NativeMethods.cs" company="bedug.com">
//     Copyright © 2012 Nils Hammar. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------
/*
 * Software to access vehicle information via the OBD-II connector.
 * 
 * Copyright © 2012 Nils Hammar
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * Alternative licensing is possible, see the licensing document.
 * 
 * The above text may not be removed or modified.
 */

namespace DynamicApiLoading.Api.Dynamic.RP1210
{
    using System;
    using System.Runtime.InteropServices;
    using System.Text;

    /// <summary>
    /// RP1210 Native API methods.
    /// </summary>
    public class NativeMethods : IDisposable
    {
        /// <summary>
        /// This function is called by the client application seeking connection with a DLL.
        /// <para>This connection corresponds to the implementation of the API for the VDA being selected.
        /// Inside the API DLL, the function allocates and initializes any client data structures,
        /// and loads, initializes, or activates any device drivers (virtual or otherwise) to communicate
        /// with the hardware and sets all client appliation variables to their defaults (EchoMode,FilterStates, etc.).</para>
        /// <para>If the connection is successful, the function shall return a unique identifier,
        /// corresponding to the ID of the client application, as assigned by the API DLL.</para>
        /// </summary>
        /// <param name="hwndClient">This parameter is no longer necessary and is unused  (Windows  3.1).
        /// The value should be set to NULL (0x00) if an application is not developed for Windows 3.1.</param>
        /// <param name="nDeviceId">The device to which the client application is requesting connection.</param>
        /// <param name="fpchProtocol">Pointer to a null-terminated string of the protocol name
        /// to be used by the device designated in the previous parameter.
        /// (See Protocol Connect String section for protocol strings and variations.)</param>
        /// <param name="lSendBuffer">A long integer for the requested size (in bytes) of the client transmit
        /// buffer to be allocated by the API for the queuing of messages sought to be ransmitted by the client
        /// application.
        /// <para>
        /// Should be passed as 0 if the application does not want to dictate the buffer size and
        /// the API DLL default of 8K is acceptable.</para></param>
        /// <param name="lReceiveBuffer">A long integer for the requested size (in bytes) of the
        /// client receive buffer to be allocated by the API for the queuing of messages meant
        /// to be received by the client application.
        /// <para>Should be passed as 0 if the application does not want to dictate the buffer
        /// size and the API DLL default of 8K is acceptable.</para></param>
        /// <param name="nIsAppPacketizingIncomingMsgs">A flag that is relevant only for J1939.
        /// <para>Should be set to zero if the application wants the lower-level components to
        /// perform the tasks of fragmenting the message into packets and return complete
        /// messages assembled from packets received.</para>
        /// <para>Should be set to 1 in the rare case where the application itself will
        /// perform the packetizing of message fragments.</para></param>
        /// <returns>If the connection is successful, then the function returns a value between 0 and 127,
        /// corresponding to the client identifier that the application program is assigned by the API DLL.
        /// <para>The application program must save this return value in order to conduct future transactions with the DLL.</para>
        /// <para>If the connection is unsuccessful, then an error code is returned that corresponds to a number greater than 127.</para>
        /// <para>The typical error codes are described below.</para>
        /// <para>More descriptive or proprietary codes may be returned by individual vendor implementations as
        /// long as the numerical equivalents of these return values are greater
        /// than 192 and are clearly documented by the vendor.</para>
        /// <code>
        /// Mnemonic (Return Codes) Description
        /// ERR_CLIENT_ALREADY_CONNECTED                A client is already connected to the specified device.
        /// ERR_CLIENT_AREA_FULL                        The maximum number of connections has been reached.
        /// ERR_CONNECT_NOT_ALLOWED                     Only one connection is allowed in the requested Mode.
        /// ERR_DEVICE_IN_USE                           The specified device is already in use and does not have the ability to maintain connections with multiple clients simultaneously.
        /// ERR_DLL_NOT_INITIALIZED                     The API DLL was not initialized.
        /// ERR_HARDWARE_NOT_RESPONDING                 The device is not responding.
        /// ERR_INVALID_DEVICE                          The specified device ID is invalid.
        /// ERR_INVALID_PROTOCOL                        The specified protocol is invalid or unsupported or
        ///                                             the extended connect string (fpchProtocol) was incorrect or unsupported.
        /// ERR_NOT_ENOUGH_MEMORY                       The API DLL could not allocate enough memory to create the client.
        /// ERR_J1708_BAUD_SET_NONSTANDARD              See RP1210_ClientConnect Notes.
        /// ERR_J1939_BAUD_SET_NONSTANDARD              See RP1210_ClientConnect Notes.
        /// ERR_CAN_BAUD_SET_NONSTANDARD                See RP1210_ClientConnect Notes.
        /// ERR_MULTIPLE_CONNECTIONS_NOT_ALLOWED_NOW    See RP1210_ClientConnect Notes.
        /// </code>
        /// </returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TRP1210ClientConnect(IntPtr hwndClient, short nDeviceId, StringBuilder fpchProtocol, int lSendBuffer, int lReceiveBuffer, short nIsAppPacketizingIncomingMsgs);

        /// <summary>
        /// RP1210 Client Disconnect
        /// </summary>
        /// <param name="nClientID">Client ID (return value from TRP1210ClientConnect in range 0 to 127)</param>
        /// <returns>Status of operation.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate short TRP1210ClientDisconnect(short nClientID);

        /// <summary>
        /// RP1210 Send Message.
        /// </summary>
        /// <param name="nClientID">Client ID (return value from TRP1210ClientConnect in range 0 to 127)</param>
        /// <param name="fpchClientMessage">Message to send.</param>
        /// <param name="nMessageSize">Size of message.</param>
        /// <param name="nNotifyStatusOnTx">Windows 3.1 legacy parameter.</param>
        /// <param name="nBlockOnSend">Flag indicate if method shall block on sending.</param>
        /// <returns>Status of operation.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate short TRP1210SendMessage(short nClientID, byte[] fpchClientMessage, short nMessageSize, short nNotifyStatusOnTx, short nBlockOnSend);

        /// <summary>
        /// RP1210 Read Message.
        /// </summary>
        /// <param name="nClientID">Client ID (return value from TRP1210ClientConnect in range 0 to 127)</param>
        /// <param name="fpchAPIMessage">Buffer to receive message to.</param>
        /// <param name="nBufferSize">Size of buffer.</param>
        /// <param name="nBlockOnRead">Flag to indicate if the method shall block until message is read.</param>
        /// <returns>0 at no message, &lt;192 for message size, &gt; 192 for error code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate short TRP1210ReadMessage(short nClientID, byte[] fpchAPIMessage, short nBufferSize, short nBlockOnRead);

        /// <summary>
        /// RP1210 Send Command.
        /// </summary>
        /// <param name="nCommandNumber">RP1210 Command Number</param>
        /// <param name="nClientID">Client ID (return value from TRP1210ClientConnect in range 0 to 127)</param>
        /// <param name="fpchClientCommand">Pointer to buffer.</param>
        /// <param name="nMessageSize">Size of buffer.</param>
        /// <returns>Status of operation.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate short TRP1210SendCommand(short nCommandNumber, short nClientID, StringBuilder fpchClientCommand, short nMessageSize);

        /// <summary>
        /// RP1210 Read Version.
        /// </summary>
        /// <param name="fpchDLLMajorVersion">DLL Major version.</param>
        /// <param name="fpchDLLMinorVersion">DLL Minor version.</param>
        /// <param name="fpchAPIMajorVersion">API Major version.</param>
        /// <param name="fpchAPIMinorVersion">API Minor version.</param>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate void TRP1210ReadVersion(StringBuilder fpchDLLMajorVersion, StringBuilder fpchDLLMinorVersion, StringBuilder fpchAPIMajorVersion, StringBuilder fpchAPIMinorVersion);

        /// <summary>
        /// RP1210 This function is called by the client application seeking to get detailed information about the vendor API and/or firmware of the device to which it is connected.
        /// </summary>
        /// <param name="nClientID">Client ID (return value from TRP1210ClientConnect in range 0 to 127)</param>
        /// <param name="fpchAPIVersionInfo">API version info.
        /// <para>Pointer to a buffer that is 17 bytes long.</para>
        /// <para>The API may return up to 16 bytes in this field (with NULL terminator) to describe the version of the API interface.</para>
        /// </param>
        /// <param name="fpchDLLVersionInfo">DLL version info.
        /// <para>Pointer to a buffer that is 17 bytes long.</para>
        /// <para>The API may return up to 16 bytes in this field (with NULL terminator) to describe the version of the DLL.</para></param>
        /// <param name="fpchFWVersionInfo">Firmware version info.
        /// <para>Pointer to a buffer that is 17 bytes long.</para>
        /// <para>The API may return up to 16 bytes in this field (with NULL terminator) to describe the version of
        /// the firmware that is present in the device.</para>
        /// <para>A NULL string is also a valid return if the VDA does not have associated firmware.</para></param>
        /// <returns>Status of operation.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate short TRP1210ReadDetailedVersion(short nClientID, StringBuilder fpchAPIVersionInfo, StringBuilder fpchDLLVersionInfo, StringBuilder fpchFWVersionInfo);

        /// <summary>
        /// RP1210 Get Hardware Status
        /// </summary>
        /// <param name="nClientID">Client ID (return value from TRP1210ClientConnect in range 0 to 127)</param>
        /// <param name="fpchClientInfo">A pointer to the buffer (allocated by the client application) where hardware status information is to be placed.</param>
        /// <param name="nInfoSize">Always set to 18 bytes.</param>
        /// <param name="nBlockOnRequest">A flag to indicate whether the function must block on requesting the hardware status or not.</param>
        /// <returns>Status of operation.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate short TRP1210GetHardwareStatus(short nClientID, StringBuilder fpchClientInfo, short nInfoSize, short nBlockOnRequest);

        /// <summary>
        /// Type declaration for dynamically loaded RP1210 API.
        /// </summary>
        /// <param name="err_code">Numerical value for the last error which occurred.</param>
        /// <param name="fpchMessage">A pointer to the buffer (allocated by the client application) of 80 bytes, used to return the error message associated with the error code.</param>
        /// <returns>Status of operation.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate short TRP1210GetErrorMsg(short err_code, StringBuilder fpchMessage);

        /// <summary>
        /// Gets RP1210_ClientConnect method instance.
        /// </summary>
        internal TRP1210ClientConnect RP1210_ClientConnect { get; private set; }

        /// <summary>
        /// Gets RP1210_ClientDisconnect method instance.
        /// </summary>
        internal TRP1210ClientDisconnect RP1210_ClientDisconnect { get; private set; }

        /// <summary>
        /// Gets RP1210_SendMessage method instance.
        /// </summary>
        internal TRP1210SendMessage RP1210_SendMessage { get; private set; }

        /// <summary>
        /// Gets RP1210_ReadMessage method instance.
        /// </summary>
        internal TRP1210ReadMessage RP1210_ReadMessage { get; private set; }

        /// <summary>
        /// Gets RP1210_SendCommand method instance.
        /// </summary>
        internal TRP1210SendCommand RP1210_SendCommand { get; private set; }

        /// <summary>
        /// Gets RP1210_ReadVersion method instance.
        /// </summary>
        internal TRP1210ReadVersion RP1210_ReadVersion { get; private set; }

        /// <summary>
        /// Gets RP1210_ReadDetailedVersion method instance.
        /// </summary>
        internal TRP1210ReadDetailedVersion RP1210_ReadDetailedVersion { get; private set; }

        /// <summary>
        /// Gets RP1210_GetHardwareStatus method instance.
        /// </summary>
        internal TRP1210GetHardwareStatus RP1210_GetHardwareStatus { get; private set; }

        /// <summary>
        /// Gets RP1210_GetErrorMsg method instance.
        /// </summary>
        internal TRP1210GetErrorMsg RP1210_GetErrorMsg { get; private set; }

        /// <summary>
        /// DLL instance handle.
        /// </summary>
        private SafeLibraryHandle safeLibraryHandle;

        /// <summary>
        /// Name of DLL.
        /// </summary>
        private string library;

        /// <summary>
        /// Initializes a new instance of the <see cref="NativeMethods" /> class.
        /// </summary>
        /// <param name="library">Name of DLL.</param>
        public NativeMethods(string library)
        {
            this.library = library;

            this.safeLibraryHandle = SafeLibraryHandle.LoadLibraryW(library);

            if (this.safeLibraryHandle.IsInvalid)
            {
                throw new DynamicLoaderException("LoadLibrary('" + library + "') failed!");
            }

            this.RP1210_ClientConnect = (TRP1210ClientConnect)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("RP1210_ClientConnect"), typeof(TRP1210ClientConnect));
            this.RP1210_ClientDisconnect = (TRP1210ClientDisconnect)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("RP1210_ClientDisconnect"), typeof(TRP1210ClientDisconnect));
            this.RP1210_SendMessage = (TRP1210SendMessage)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("RP1210SendMessage"), typeof(TRP1210SendMessage));

            this.RP1210_ReadMessage = (TRP1210ReadMessage)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("RP1210_ReadMessage"), typeof(TRP1210ReadMessage));
            this.RP1210_SendCommand = (TRP1210SendCommand)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("RP1210_SendCommand"), typeof(TRP1210SendCommand));
            this.RP1210_ReadVersion = (TRP1210ReadVersion)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("RP1210_ReadVersion"), typeof(TRP1210ReadVersion));

            this.RP1210_ReadDetailedVersion = (TRP1210ReadDetailedVersion)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("RP1210_ReadDetailedVersion"), typeof(TRP1210ReadDetailedVersion));
            this.RP1210_GetHardwareStatus = (TRP1210GetHardwareStatus)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("RP1210_GetHardwareStatus"), typeof(TRP1210GetHardwareStatus));
            this.RP1210_GetErrorMsg = (TRP1210GetErrorMsg)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("RP1210_GetErrorMsg"), typeof(TRP1210GetErrorMsg));
        }

        /// <summary>
        /// Dispose instance.
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Dispose instance.
        /// </summary>
        /// <param name="disposing">'true' if call to Dispose() was made, 'false' if the class was finalized.</param>
        protected virtual void Dispose(bool disposing)
        {
            this.safeLibraryHandle.Dispose();
        }

        /// <summary>
        /// Finalizes an instance of the <see cref="NativeMethods" /> class.
        /// </summary>
        ~NativeMethods()
        {
            this.Dispose(false);
        }

        /// <summary>
        /// Gets the address of the given procedure, throws Exception when failing.
        /// </summary>
        /// <param name="functionName">Name of procedure to locate.</param>
        /// <returns>Pointer to function</returns>
        /// <exception cref="DynamicLoaderException">Thrown when unable to get address to function.</exception>
        private IntPtr getProcedureAddress(string functionName)
        {
            IntPtr pAddress = this.safeLibraryHandle.GetProcAddress(functionName);

            if (pAddress == IntPtr.Zero)
            {
                throw new DynamicLoaderException("GetProcAddress('" + functionName + "'), library '" + this.library + "' failed!");
            }

            return pAddress;
        }
    }
}