/*

   This Source Code Form is subject to the terms of the Mozilla Public

   License, v. 2.0. If a copy of the MPL was not distributed with this

   file, You can obtain one at http://mozilla.org/MPL/2.0/.

   Copyright (C) 2009-2012 Michael Möller <mmoeller@openhardwaremonitor.org>

 */

 using System;

 using System.Runtime.InteropServices;

 namespace OpenHardwareMonitor.Hardware.TBalancer {

   internal enum FT_DEVICE : uint {

     FT_DEVICE_232BM,

     FT_DEVICE_232AM,

     FT_DEVICE_100AX,

     FT_DEVICE_UNKNOWN,

     FT_DEVICE_2232C,

     FT_DEVICE_232R,

     FT_DEVICE_2232H,

     FT_DEVICE_4232H

   }

   internal enum FT_STATUS {

     FT_OK,

     FT_INVALID_HANDLE,

     FT_DEVICE_NOT_FOUND,

     FT_DEVICE_NOT_OPENED,

     FT_IO_ERROR,

     FT_INSUFFICIENT_RESOURCES,

     FT_INVALID_PARAMETER,

     FT_INVALID_BAUD_RATE,

     FT_DEVICE_NOT_OPENED_FOR_ERASE,

     FT_DEVICE_NOT_OPENED_FOR_WRITE,

     FT_FAILED_TO_WRITE_DEVICE,

     FT_EEPROM_READ_FAILED,

     FT_EEPROM_WRITE_FAILED,

     FT_EEPROM_ERASE_FAILED,

     FT_EEPROM_NOT_PRESENT,

     FT_EEPROM_NOT_PROGRAMMED,

     FT_INVALID_ARGS,

     FT_OTHER_ERROR

   }

   internal enum FT_FLOW_CONTROL : ushort {

     FT_FLOW_DTR_DSR = 512,

     FT_FLOW_NONE = 0,

     FT_FLOW_RTS_CTS = 256,

     FT_FLOW_XON_XOFF = 1024,

   }

   internal enum FT_PURGE : uint {

     FT_PURGE_RX = 1,

     FT_PURGE_TX = 2,

     FT_PURGE_ALL = 3,

   }

   [StructLayout(LayoutKind.Sequential)]

   internal struct FT_HANDLE {

     private readonly uint handle;

   }

   [StructLayout(LayoutKind.Sequential)]

   internal struct FT_DEVICE_INFO_NODE {    

     public uint Flags;

     public FT_DEVICE Type; 

     public uint ID; 

     public uint LocId; 

     [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]

     public string SerialNumber; 

     [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]

     public string Description;

     public FT_HANDLE Handle;

   }

   internal class FTD2XX {

     public delegate FT_STATUS FT_CreateDeviceInfoListDelegate(

       out uint numDevices);

     public delegate FT_STATUS FT_GetDeviceInfoListDelegate(

       [Out] FT_DEVICE_INFO_NODE[] deviceInfoNodes, ref uint length);

     public delegate FT_STATUS FT_OpenDelegate(int device, out FT_HANDLE handle);

     public delegate FT_STATUS FT_CloseDelegate(FT_HANDLE handle);

     public delegate FT_STATUS FT_SetBaudRateDelegate(FT_HANDLE handle,

       uint baudRate);

     public delegate FT_STATUS FT_SetDataCharacteristicsDelegate(

       FT_HANDLE handle, byte wordLength, byte stopBits, byte parity);

     public delegate FT_STATUS FT_SetFlowControlDelegate(FT_HANDLE handle,

       FT_FLOW_CONTROL flowControl, byte xon, byte xoff);

     public delegate FT_STATUS FT_SetTimeoutsDelegate(FT_HANDLE handle,

       uint readTimeout, uint writeTimeout);

     public delegate FT_STATUS FT_WriteDelegate(FT_HANDLE handle, byte[] buffer,

       uint bytesToWrite, out uint bytesWritten);

     public delegate FT_STATUS FT_PurgeDelegate(FT_HANDLE handle, FT_PURGE mask);

     public delegate FT_STATUS FT_GetStatusDelegate(FT_HANDLE handle,

       out uint amountInRxQueue, out uint amountInTxQueue, out uint eventStatus);

     public delegate FT_STATUS FT_ReadDelegate(FT_HANDLE handle, 

       [Out] byte[] buffer, uint bytesToRead, out uint bytesReturned);

     public delegate FT_STATUS FT_ReadByteDelegate(FT_HANDLE handle,

       out byte buffer, uint bytesToRead, out uint bytesReturned);

     public static readonly FT_CreateDeviceInfoListDelegate 

       FT_CreateDeviceInfoList = CreateDelegate<

       FT_CreateDeviceInfoListDelegate>("FT_CreateDeviceInfoList");

     public static readonly FT_GetDeviceInfoListDelegate 

       FT_GetDeviceInfoList = CreateDelegate<

       FT_GetDeviceInfoListDelegate>("FT_GetDeviceInfoList");

     public static readonly FT_OpenDelegate 

       FT_Open = CreateDelegate<

       FT_OpenDelegate>("FT_Open");

     public static readonly FT_CloseDelegate 

       FT_Close = CreateDelegate<

       FT_CloseDelegate>("FT_Close");

     public static readonly FT_SetBaudRateDelegate 

       FT_SetBaudRate = CreateDelegate<

       FT_SetBaudRateDelegate>("FT_SetBaudRate");

     public static readonly FT_SetDataCharacteristicsDelegate 

       FT_SetDataCharacteristics = CreateDelegate<

       FT_SetDataCharacteristicsDelegate>("FT_SetDataCharacteristics");

     public static readonly FT_SetFlowControlDelegate 

       FT_SetFlowControl = CreateDelegate<

       FT_SetFlowControlDelegate>("FT_SetFlowControl");

     public static readonly FT_SetTimeoutsDelegate 

       FT_SetTimeouts = CreateDelegate<

       FT_SetTimeoutsDelegate>("FT_SetTimeouts");

     public static readonly FT_WriteDelegate 

       FT_Write = CreateDelegate<

       FT_WriteDelegate>("FT_Write");

     public static readonly FT_PurgeDelegate 

       FT_Purge = CreateDelegate<

       FT_PurgeDelegate>("FT_Purge");

     public static readonly FT_GetStatusDelegate 

       FT_GetStatus = CreateDelegate<

       FT_GetStatusDelegate>("FT_GetStatus");

     public static readonly FT_ReadDelegate 

       FT_Read = CreateDelegate<

       FT_ReadDelegate>("FT_Read");

     public static readonly FT_ReadByteDelegate

       FT_ReadByte = CreateDelegate<

       FT_ReadByteDelegate>("FT_Read");

     private FTD2XX() { }

     public static FT_STATUS Write(FT_HANDLE handle, byte[] buffer) {

       uint bytesWritten;

       FT_STATUS status = FT_Write(handle, buffer, (uint)buffer.Length, 

         out bytesWritten);

       if (bytesWritten != buffer.Length)

         return FT_STATUS.FT_FAILED_TO_WRITE_DEVICE;

       else

         return status;

     }

     public static int BytesToRead(FT_HANDLE handle) {

       uint amountInRxQueue;

       uint amountInTxQueue;

       uint eventStatus;

       if (FT_GetStatus(handle, out amountInRxQueue, out amountInTxQueue,

         out eventStatus) == FT_STATUS.FT_OK) {

         return (int)amountInRxQueue;

       } else {

         return 0;

       }

     }

     public static byte ReadByte(FT_HANDLE handle) {

       byte buffer;

       uint bytesReturned;

       FT_STATUS status = FT_ReadByte(handle, out buffer, 1, out bytesReturned);

       if (status != FT_STATUS.FT_OK || bytesReturned != 1)

         throw new InvalidOperationException();

       return buffer;

     }

     public static void Read(FT_HANDLE handle, byte[] buffer) {

       uint bytesReturned;

       FT_STATUS status = 

         FT_Read(handle, buffer, (uint)buffer.Length, out bytesReturned);

       if (status != FT_STATUS.FT_OK || bytesReturned != buffer.Length)

         throw new InvalidOperationException();

     }

     private static string GetDllName() {

       int p = (int)Environment.OSVersion.Platform;

       if ((p == 4) || (p == 128))

         return "libftd2xx.so";

       else

         return "ftd2xx.dll";

     }

     private static T CreateDelegate<T>(string entryPoint)

       where T : class {

       DllImportAttribute attribute = new DllImportAttribute(GetDllName());

       attribute.CallingConvention = CallingConvention.StdCall;

       attribute.PreserveSig = true;

       attribute.EntryPoint = entryPoint;

       T newDelegate;

       PInvokeDelegateFactory.CreateDelegate(attribute, out newDelegate);

       return newDelegate;

     }

   }

 }