//-----------------------------------------------------------------------
// <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.J2534
{
    using System;
    using System.Runtime.InteropServices;

    /// <summary>
    /// J2534 PassThru API Native Method.s
    /// </summary>
    public unsafe class NativeMethods : IDisposable
    {
        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="pName">Name of device [not used, set to 'null']</param>
        /// <param name="pDeviceID">Instance ID for device, out parameter.</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruOpen(void* pName, int* pDeviceID);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="DeviceID">Instance ID for device</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruClose(int DeviceID);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="DeviceID">Instance ID for device</param>
        /// <param name="ProtocolID">Protocol ID</param>
        /// <param name="Flags">Connection flags</param>
        /// <param name="Baudrate">Baudrate for device</param>
        /// <param name="pChannelID">Channel ID (out parameter)</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruConnect(int DeviceID, int ProtocolID, int Flags, int Baudrate, int* pChannelID);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="ChannelID">Channel ID</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruDisconnect(int ChannelID);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="ChannelID">Channel ID</param>
        /// <param name="pMsg">Pointer to message struct (out parameter)</param>
        /// <param name="pNumMsgs">Pointer to number of messages (out parameter)</param>
        /// <param name="Timeout">Timeout value.</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruReadMsgs(int ChannelID, PASSTHRU_MSG* pMsg, int* pNumMsgs, int Timeout);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="ChannelID">Channel ID</param>
        /// <param name="pMsg">Pointer to message struct(s).</param>
        /// <param name="pNumMsgs">Number of messages.</param>
        /// <param name="Timeout">Timeout value.</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruWriteMsgs(int ChannelID, PASSTHRU_MSG* pMsg, int* pNumMsgs, int Timeout);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="ChannelID">Channel ID</param>
        /// <param name="pMsg">Pointer to message struct.</param>
        /// <param name="pMsgID">Message ID (out parameter)</param>
        /// <param name="TimeInterval">Timeout value</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruStartPeriodicMsg(int ChannelID, PASSTHRU_MSG* pMsg, int* pMsgID, int TimeInterval);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="ChannelID">Channel ID</param>
        /// <param name="MsgID">Message ID</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruStopPeriodicMsg(int ChannelID, int MsgID);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="ChannelID">Channel ID</param>
        /// <param name="FilterType">Filter type</param>
        /// <param name="pMaskMsg">Mask message</param>
        /// <param name="pPatternMsg">Pattern message</param>
        /// <param name="pFlowControlMsg">Flow control message</param>
        /// <param name="pMsgID">Filter ID</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruStartMsgFilter(
            int ChannelID,
            int FilterType,
            PASSTHRU_MSG* pMaskMsg,
            PASSTHRU_MSG* pPatternMsg,
            PASSTHRU_MSG* pFlowControlMsg,
            int* pMsgID);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="ChannelID">Channel ID</param>
        /// <param name="MsgID">Filter ID</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruStopMsgFilter(int ChannelID, int MsgID);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="DeviceID">Device ID</param>
        /// <param name="Pin">Connector pin number</param>
        /// <param name="Voltage">Voltage to set on pin</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruSetProgrammingVoltage(int DeviceID, int Pin, int Voltage);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="DeviceID">Device ID</param>
        /// <param name="pFirmwareVersion">Firmware version (out value)</param>
        /// <param name="pDllVersion">DLL version (out value)</param>
        /// <param name="pApiVersion">API version (out value)</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruReadVersion(int DeviceID, byte* pFirmwareVersion, byte* pDllVersion, byte* pApiVersion);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="pErrorDescription">Error description (out value)</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruGetLastError(sbyte* pErrorDescription);

        /// <summary>
        /// Type declaration for dynamically loaded J2534 API.
        /// </summary>
        /// <param name="ChannelID">Channel ID</param>
        /// <param name="IoctlID">IOCTL ID</param>
        /// <param name="pInput">Pointer to in data.</param>
        /// <param name="pOutput">Pointer to out data.</param>
        /// <returns>Status code.</returns>
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        internal delegate int TPassThruIoctl(
            int ChannelID,
            int IoctlID,
            void* pInput,
            void* pOutput);

        /// <summary>
        /// Gets PassThruOpen method call interface.
        /// </summary>
        internal TPassThruOpen PassThruOpen { get; private set; }

        /// <summary>
        /// Gets PassThruClose method call interface.
        /// </summary>
        internal TPassThruClose PassThruClose { get; private set; }

        /// <summary>
        /// Gets PassThruConnect method call interface.
        /// </summary>
        internal TPassThruConnect PassThruConnect { get; private set; }

        /// <summary>
        /// Gets PassThruDisconnect method call interface.
        /// </summary>
        internal TPassThruDisconnect PassThruDisconnect { get; private set; }

        /// <summary>
        /// Gets PassThruReadMsgs method call interface.
        /// </summary>
        internal TPassThruReadMsgs PassThruReadMsgs { get; private set; }

        /// <summary>
        /// Gets PassThruWriteMsgs method call interface.
        /// </summary>
        internal TPassThruWriteMsgs PassThruWriteMsgs { get; private set; }

        /// <summary>
        /// Gets PassThruStartPeriodicMsg method call interface.
        /// </summary>
        internal TPassThruStartPeriodicMsg PassThruStartPeriodicMsg { get; private set; }

        /// <summary>
        /// Gets PassThruStopPeriodicMsg method call interface.
        /// </summary>
        internal TPassThruStopPeriodicMsg PassThruStopPeriodicMsg { get; private set; }

        /// <summary>
        /// Gets PassThruStartMsgFilter method call interface.
        /// </summary>
        internal TPassThruStartMsgFilter PassThruStartMsgFilter { get; private set; }

        /// <summary>
        /// Gets PassThruStopMsgFilter method call interface.
        /// </summary>
        internal TPassThruStopMsgFilter PassThruStopMsgFilter { get; private set; }

        /// <summary>
        /// Gets PassThruSetProgrammingVoltage method call interface.
        /// </summary>
        internal TPassThruSetProgrammingVoltage PassThruSetProgrammingVoltage { get; private set; }

        /// <summary>
        /// Gets PassThruReadVersion method call interface.
        /// </summary>
        internal TPassThruReadVersion PassThruReadVersion { get; private set; }

        /// <summary>
        /// Gets PassThruGetLastError method call interface.
        /// </summary>
        internal TPassThruGetLastError PassThruGetLastError { get; private set; }

        /// <summary>
        /// Gets PassThruIoctl method call interface.
        /// </summary>
        internal TPassThruIoctl PassThruIoctl { 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.PassThruOpen = (TPassThruOpen)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruOpen"), typeof(TPassThruOpen));
            this.PassThruClose = (TPassThruClose)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruClose"), typeof(TPassThruClose));
            this.PassThruConnect = (TPassThruConnect)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruConnect"), typeof(TPassThruConnect));
            this.PassThruDisconnect = (TPassThruDisconnect)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruDisconnect"), typeof(TPassThruDisconnect));
            this.PassThruReadMsgs = (TPassThruReadMsgs)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruReadMsgs"), typeof(TPassThruReadMsgs));
            this.PassThruWriteMsgs = (TPassThruWriteMsgs)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruWriteMsgs"), typeof(TPassThruWriteMsgs));
            this.PassThruStartPeriodicMsg = (TPassThruStartPeriodicMsg)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruStartPeriodicMsg"), typeof(TPassThruStartPeriodicMsg));
            this.PassThruStopPeriodicMsg = (TPassThruStopPeriodicMsg)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruStopPeriodicMsg"), typeof(TPassThruStopPeriodicMsg));
            this.PassThruStartMsgFilter = (TPassThruStartMsgFilter)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruStartMsgFilter"), typeof(TPassThruStartMsgFilter));
            this.PassThruStopMsgFilter = (TPassThruStopMsgFilter)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruStopMsgFilter"), typeof(TPassThruStopMsgFilter));
            this.PassThruSetProgrammingVoltage = (TPassThruSetProgrammingVoltage)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruSetProgrammingVoltage"), typeof(TPassThruSetProgrammingVoltage));
            this.PassThruReadVersion = (TPassThruReadVersion)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruReadVersion"), typeof(TPassThruReadVersion));
            this.PassThruGetLastError = (TPassThruGetLastError)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruGetLastError"), typeof(TPassThruGetLastError));
            this.PassThruIoctl = (TPassThruIoctl)Marshal.GetDelegateForFunctionPointer(this.getProcedureAddress("PassThruIoctl"), typeof(TPassThruIoctl));
        }

        /// <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;
        }
    }
}