// 32feet.NET - Personal Area Networking for .NET
//
// InTheHand.Net.Bluetooth.Msft.BluetoothClient
// 
// Copyright (c) 2003-2008 In The Hand Ltd, All rights reserved.
// This source code is licensed under the MIT License

//#define WIN32_READ_BTH_DEVICE_INFO

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using Microsoft.Win32;
using InTheHand.Net.Bluetooth.Factory;
using InTheHand.Net.Sockets;
using InTheHand.Runtime.InteropServices;
using AsyncResult_BeginDiscoverDevices = InTheHand.Net.AsyncResult<
    InTheHand.Net.Bluetooth.Factory.IBluetoothDeviceInfo[],
    InTheHand.Net.Bluetooth.Msft.SocketBluetoothClient.DiscoDevsParamsWithLive>;
using List_IBluetoothDeviceInfo = System.Collections.Generic.List<InTheHand.Net.Bluetooth.Factory.IBluetoothDeviceInfo>;
using InTheHand.SystemCore;

namespace InTheHand.Net.Bluetooth.Msft
{
    class SocketBluetoothClient : IBluetoothClient
    {
        readonly BluetoothFactory _fcty;
        private bool cleanedUp = false;
        private ISocketOptionHelper m_optionHelper;
#if WinXP
        // If SetPin(String) is called before connect we need to know the remote 
        // address to start the BluetoothWin32Authenticator for, so store this 
        // so we can start the authenticator at connect-time.
        string m_pinForConnect;
#endif

        #region Constructor
#if NETCF
        static SocketBluetoothClient()
        {
            InTheHand.Net.PlatformVerification.ThrowException();
        }
#endif

        internal SocketBluetoothClient(BluetoothFactory fcty)
        {
            Debug.Assert(fcty != null, "ArgNull");
            _fcty = fcty;
            try {
                this.Client = CreateSocket();
            } catch (SocketException se) {
                throw new PlatformNotSupportedException("32feet.NET does not support the Bluetooth stack on this device.", se);
            }
            m_optionHelper = CreateSocketOptionHelper(this.Client);
        }
        internal SocketBluetoothClient(BluetoothFactory fcty, BluetoothEndPoint localEP)
            : this(fcty)
        {
            if (localEP == null) {
                throw new ArgumentNullException("localEP");
            }

            //bind to specific local endpoint
            var bindEP = PrepareBindEndPoint(localEP);
            this.Client.Bind(bindEP);
        }
        
        internal SocketBluetoothClient(BluetoothFactory fcty, Socket acceptedSocket)
        {
            Debug.Assert(fcty != null, "ArgNull");
            _fcty = fcty;
            this.Client = acceptedSocket;
            active = true;
            m_optionHelper = CreateSocketOptionHelper(this.Client);
        }


        protected virtual Socket CreateSocket()
        {
            return new Socket(BluetoothAddressFamily, SocketType.Stream, BluetoothProtocolType.RFComm);
        }

        protected virtual AddressFamily BluetoothAddressFamily
        {
            get { return AddressFamily32.Bluetooth; }
        }

        protected virtual BluetoothEndPoint PrepareConnectEndPoint(BluetoothEndPoint serverEP)
        {
            return serverEP;
        }

        protected virtual BluetoothEndPoint PrepareBindEndPoint(BluetoothEndPoint serverEP)
        {
            return serverEP;
        }

        protected virtual ISocketOptionHelper CreateSocketOptionHelper(Socket socket)
        {
            return new MsftSocketOptionHelper(socket);
        }
        #endregion

        #region InquiryAccessCode
        private int iac = BluetoothAddress.Giac; //0x9E8B33;
#if NETCF
        /// <summary>
        /// 
        /// </summary>
        public int InquiryAccessCode
        {
            get
            {
                return iac;
            }
            set
            {
                iac = value;
            }
        }
#else
        public int InquiryAccessCode
        {
            get { throw new NotSupportedException(); }
            set { throw new NotSupportedException(); }
        }
#endif
        #endregion

        #region Query Length

        //length of time for query
        private TimeSpan inquiryLength = new TimeSpan(0, 0, 10);

        /// <summary>
        /// Amount of time allowed to perform the query.
        /// </summary>
        /// <remarks>On Windows CE the actual value used is expressed in units of 1.28 seconds, so will be the nearest match for the value supplied.
        /// The default value is 10 seconds. The maximum is 60 seconds.</remarks>
        public TimeSpan InquiryLength
        {
            get
            {
                return inquiryLength;
            }
            set
            {
                if ((value.TotalSeconds > 0) && (value.TotalSeconds <= 60)) {
                    inquiryLength = value;
                } else {
                    throw new ArgumentOutOfRangeException("value",
                        "QueryLength must be a positive timespan between 0 and 60 seconds.");
                }
            }
        }
        #endregion

        #region Discover Devices
        /// <summary>
        /// Discovers accessible Bluetooth devices and returns their names and addresses.
        /// </summary>
        /// <param name="maxDevices">The maximum number of devices to get information about.</param>
        /// <param name="authenticated">True to return previously authenticated/paired devices.</param>
        /// <param name="remembered">True to return remembered devices.</param>
        /// <param name="unknown">True to return previously unknown devices.</param>
        /// <param name="discoverableOnly">True to return only discoverable devices
        /// (where both in range and in discoverable mode).
        /// When <see langword="true"/> all other flags are ignored.
        /// <strong>Note: Does NOT work on Win32 with the Microsoft stack.</strong>
        /// </param>
        /// <returns>An array of BluetoothDeviceInfo objects describing the devices discovered.</returns>
        /// -
        /// <remarks>
        /// <para>The <see paramref="discoverableOnly"/> flag will discover only 
        /// the devices that are in range and are in discoverable mode.  This works 
        /// only on WM/CE with the Microsoft stack, or on any platform with the 
        /// Widcomm stack.
        /// </para>
        /// <para>
        /// It does not work on desktop Windows with the Microsoft 
        /// stack, where the in range and remembered devices are returned already 
        /// merged!  There simple all devices will be returned.  Even the 
        /// <see cref="InTheHand.Net.Sockets.BluetoothDeviceInfo.LastSeen">BluetoothDeviceInfo.LastSeen</see>
        /// property is of no use there: on XP and Vista at least the value provided 
        /// is always simply the current time.
        /// </para>
        /// </remarks>
        IBluetoothDeviceInfo[] IBluetoothClient.DiscoverDevices(int maxDevices,
            bool authenticated, bool remembered, bool unknown, bool discoverableOnly)
        {
            return DiscoverDevices(maxDevices,
                authenticated, remembered, unknown, discoverableOnly,
                null, null);
        }

        public virtual IBluetoothDeviceInfo[] DiscoverDevices(int maxDevices,
            bool authenticated, bool remembered, bool unknown, bool discoverableOnly,
            InTheHand.Net.Sockets.BluetoothClient.LiveDiscoveryCallback liveDiscoHandler, object liveDiscoState)
        {
#if !NETCF
            //   In the MSFT+Win32 API there's no simple way to get only the
            // in-range-discoverable devices, and thus it can't provide
            // 'discoverableOnly' nor live discovery.  So, we register for the
            // native event whilst we run a normal discovery.  We use the
            // native event to raise our live event and to gather the devices
            // to be included in the discoverableOnly result.
            //   Note the event seems NOT be raised on WinXP in this case.
            //   The event (on Win7 at least) raises lots of apparently duplicate
            // events, so we need to do some filtering for both results.
            var realLiveDiscoHandler = liveDiscoHandler;
            //if (realLiveDiscoHandler != null) Debug.Assert(discoverableOnly || unknown, "You want live events from 'remembered'?!?");
            bool keepDiscoOnly = false;
            if (discoverableOnly) {
                keepDiscoOnly = true;
                unknown = authenticated = remembered = true;
                discoverableOnly = false;
            }
            BluetoothWin32Events events;
            EventHandler<BluetoothWin32RadioInRangeEventArgs> radioInRangeHandler;
            List<IBluetoothDeviceInfo> seenDevices;
            if (keepDiscoOnly || realLiveDiscoHandler != null) {
                events = BluetoothWin32Events.GetInstance();
                seenDevices = new List<IBluetoothDeviceInfo>();
                radioInRangeHandler = delegate(object sender, BluetoothWin32RadioInRangeEventArgs e) {
                    var newdevice = e.DeviceWindows;
                    Debug.WriteLine("Radio in range: " + newdevice.DeviceAddress);
                    bool unique = BluetoothDeviceInfo.AddUniqueDevice(seenDevices, newdevice);
                    if (unique && realLiveDiscoHandler != null) {
                        Debug.WriteLine("Live IS unique.");
                        realLiveDiscoHandler(newdevice, liveDiscoState);
                    } else { //COVERAGE
                        Debug.WriteLine("Live is NOT unique ("
                            + unique + "," + realLiveDiscoHandler != null + ").");
                    }
                };
                events.InRange += radioInRangeHandler;
            } else {
                events = null;
                radioInRangeHandler = null;
                seenDevices = null;
            }
            // Don't use the WM live-disco functionality.
            liveDiscoHandler = null;
#endif
            IBluetoothDeviceInfo[] result;
            try {
                result = DoDiscoverDevices(maxDevices,
                    authenticated, remembered, unknown, discoverableOnly,
                    liveDiscoHandler, liveDiscoState);
            } finally {
#if !NETCF
                if (events != null && radioInRangeHandler != null) {
                    events.InRange -= radioInRangeHandler;
                }
#endif
            }
#if !NETCF
            if (keepDiscoOnly) {
                Debug.Assert(seenDevices != null, "Should have created list 'seenDevices' above!");
                Debug.WriteLine("Disco result: " + result.Length + ", liveDevice: " + seenDevices.Count);
                result = BluetoothDeviceInfo.Intersect(result, seenDevices);
                Debug.WriteLine("Result result: " + result.Length);
            }
#endif
            return result;
        }

        IBluetoothDeviceInfo[] DoDiscoverDevices(int maxDevices,
            bool authenticated, bool remembered, bool unknown, bool discoverableOnly,
            InTheHand.Net.Sockets.BluetoothClient.LiveDiscoveryCallback liveDiscoHandler, object liveDiscoState)
        {
            WqsOffset.AssertCheckLayout();
            CsaddrInfoOffsets.AssertCheckLayout();
            //
#if !NETCF
            Debug.Assert(liveDiscoHandler == null, "Don't use the NETCF live-disco feature on Win32!");
#endif
#if WinXP
            const bool Win32DiscoverableOnlyIncludesAllDevices = false;
#endif
            var prototype = new BluetoothEndPoint(BluetoothAddress.None, BluetoothService.Empty);
            int discoveredDevices = 0;
            List_IBluetoothDeviceInfo al = null;

            IntPtr handle = IntPtr.Zero;
            int lookupresult = 0;
            /* Windows XP SP3
               Begin takes the full Inquiry time.
                        12:09:15.7968750: Begin
                10.265s 12:09:26.0625000: Begin complete
                        12:09:26.0625000: Next
                        12:09:26.0625000: Next Complete
                        ...
                        12:09:26.1718750: Next
                        12:09:26.1718750: Next Complete
                        12:09:26.1718750: End
                        12:09:26.1718750: End Complete
             */
            /* WM 6 SP
               Begin is quick, Next blocks until a device is found.
                       13:46:47.1760000: Begin
                       13:46:47.2350000: Begin complete
                       13:46:47.2360000: Next
               10.537s	13:46:57.7730000: Next Complete
                       13:46:57.8910000: Next
                       13:46:57.8940000: Next Complete
                       13:46:57.8950000: Next
                       13:46:57.8960000: Next Complete
                       13:46:57.8960000: End
                       13:46:57.8990000: End Complete

            */
            System.Text.StringBuilder timings = null;
#if DEBUG
      //      timings = new System.Text.StringBuilder();
#endif
            Action<string> markTime = delegate(string name) {
                if (timings != null)
                    timings.AppendFormat(CultureInfo.InvariantCulture,
                        "{1}: {0}\r\n", name, DateTime.UtcNow.TimeOfDay);
            };

#if WinXP
            if (discoverableOnly && !Win32DiscoverableOnlyIncludesAllDevices) {
                // No way to separate out the devices-in-range on Win32. :-(
                return new IBluetoothDeviceInfo[0];
            }
#endif
#if NETCF
            DateTime discoTime = DateTime.UtcNow;
            if(unknown || discoverableOnly)
            {
#endif
            al = new List_IBluetoothDeviceInfo();
            byte[] buffer = new byte[1024];
            BitConverter.GetBytes(WqsOffset.StructLength_60).CopyTo(buffer, WqsOffset.dwSize_0);
            BitConverter.GetBytes(WqsOffset.NsBth_16).CopyTo(buffer, WqsOffset.dwNameSpace_20);

            int bufferlen = buffer.Length;


            BTHNS_INQUIRYBLOB bib = new BTHNS_INQUIRYBLOB();
            bib.LAP = iac;// 0x9E8B33;

#if NETCF
                bib.length = Convert.ToByte(inquiryLength.TotalSeconds / 1.28);
                bib.num_responses = Convert.ToByte(maxDevices);
#else
            bib.length = Convert.ToByte(inquiryLength.TotalSeconds);
#endif
            GCHandle hBib = GCHandle.Alloc(bib, GCHandleType.Pinned);
            IntPtr pBib = hBib.AddrOfPinnedObject();

            BLOB b = new BLOB(8, pBib);


            GCHandle hBlob = GCHandle.Alloc(b, GCHandleType.Pinned);

            Marshal32.WriteIntPtr(buffer, WqsOffset.lpBlob_56, hBlob.AddrOfPinnedObject());


            //start looking for Bluetooth devices
            LookupFlags flags = LookupFlags.Containers;

#if WinXP
            //ensure cache is cleared on XP when looking for new devices
            if (unknown || discoverableOnly) {
                flags |= LookupFlags.FlushCache;
            }
#endif
            markTime("Begin");
            lookupresult = NativeMethods.WSALookupServiceBegin(buffer, flags, out handle);
            markTime("Begin complete");

            hBlob.Free();
            hBib.Free();

            // TODO ?Change "while(...maxDevices)" usage on WIN32?
            while (discoveredDevices < maxDevices && lookupresult != -1) {
                markTime("Next");
#if NETCF
					lookupresult = NativeMethods.WSALookupServiceNext(handle, LookupFlags.ReturnAddr | LookupFlags.ReturnBlob , ref bufferlen, buffer);
#else
                LookupFlags flagsNext = LookupFlags.ReturnAddr;
#if WIN32_READ_BTH_DEVICE_INFO
                    flagsNext |= LookupFlags.ReturnBlob;
#endif
                lookupresult = NativeMethods.WSALookupServiceNext(handle, flagsNext, ref bufferlen, buffer);
#endif
                markTime("Next Complete");

                if (lookupresult != -1) {
                    //increment found count
                    discoveredDevices++;


                    //status
#if WinXP
                    BTHNS_RESULT status = (BTHNS_RESULT)BitConverter.ToInt32(buffer, WqsOffset.dwOutputFlags_52);
                    bool devAuthd = ((status & BTHNS_RESULT.Authenticated) == BTHNS_RESULT.Authenticated);
                    bool devRembd = ((status & BTHNS_RESULT.Remembered) == BTHNS_RESULT.Remembered);
                    if (devAuthd && !devRembd) {
                        System.Diagnostics.Debug.WriteLine("Win32 BT disco: Auth'd but NOT Remembered.");
                    }
                    bool devUnkwn = !devRembd && !devAuthd;
                    bool include = (authenticated && devAuthd) || (remembered && devRembd) || (unknown && devUnkwn);
                    Debug.Assert(!discoverableOnly, "Expected short circuit for Win32 unsupported discoverableOnly!");
                    if (include)
#else
                        if(true)
#endif
 {
#if NETCF
                            IntPtr lpBlob = (IntPtr)BitConverter.ToInt32(buffer, 56);
                            BLOB ib = (BLOB)Marshal.PtrToStructure(lpBlob, typeof(BLOB));
                            BthInquiryResult bir = (BthInquiryResult)Marshal.PtrToStructure(ib.pBlobData, typeof(BthInquiryResult));
#endif
                        //struct CSADDR_INFO {
                        //    SOCKET_ADDRESS LocalAddr;
                        //    SOCKET_ADDRESS RemoteAddr;
                        //    INT iSocketType;
                        //    INT iProtocol;
                        //}
                        //struct SOCKET_ADDRESS {
                        //    LPSOCKADDR lpSockaddr;
                        //    INT iSockaddrLength;
                        //}
                        //pointer to outputbuffer
                        IntPtr bufferptr = Marshal32.ReadIntPtr(buffer, WqsOffset.lpcsaBuffer_48);
                        //remote socket address
                        IntPtr sockaddrptr = Marshal32.ReadIntPtr(bufferptr, CsaddrInfoOffsets.OffsetRemoteAddr_lpSockaddr_8);
                        //remote socket len
                        int sockaddrlen = Marshal.ReadInt32(bufferptr, CsaddrInfoOffsets.OffsetRemoteAddr_iSockaddrLength_12);


                        SocketAddress btsa = new SocketAddress(AddressFamily32.Bluetooth, sockaddrlen);

                        for (int sockbyte = 0; sockbyte < sockaddrlen; sockbyte++) {
                            btsa[sockbyte] = Marshal.ReadByte(sockaddrptr, sockbyte);
                        }

                        var bep = (BluetoothEndPoint)prototype.Create(btsa);

                        //new deviceinfo
                        IBluetoothDeviceInfo newdevice;

#if NETCF
						newdevice = new WindowsBluetoothDeviceInfo(bep.Address, bir.cod);
                        // Built-in to Win32 so only do on NETCF
                        newdevice.SetDiscoveryTime(discoTime);
#else
                        newdevice = new WindowsBluetoothDeviceInfo(bep.Address);
#if WIN32_READ_BTH_DEVICE_INFO
                        ReadBlobBTH_DEVICE_INFO(buffer, newdevice);
#endif
#endif
                        //add to discovered list
                        al.Add(newdevice);
                        if (liveDiscoHandler != null) {
                            liveDiscoHandler(newdevice, liveDiscoState);
                        }
                    }


                }
            }//while
#if NETCF
			}
#endif

            //stop looking
            if (handle != IntPtr.Zero) {
                markTime("End");
                lookupresult = NativeMethods.WSALookupServiceEnd(handle);
                markTime("End Complete");
            }
            if (timings != null) {
                Debug.WriteLine(timings);
#if !NETCF
                Console.WriteLine(timings);
#endif
            }

#if NETCF
            List_IBluetoothDeviceInfo known = WinCEReadKnownDevicesFromRegistry();
            al = BluetoothClient.DiscoverDevicesMerge(authenticated, remembered, unknown,
                known, al, discoverableOnly, discoTime);
#endif


            //return results
            if (al.Count == 0) {
                //special case for empty collection
                return new IBluetoothDeviceInfo[0] { };
            }

            return (IBluetoothDeviceInfo[])al.ToArray(
#if V1
                typeof(IBluetoothDeviceInfo)
#endif
);
        }

#if WinXP
        private void ReadBlobBTH_DEVICE_INFO(byte[] buffer, IBluetoothDeviceInfo dev)
        {
            // XXXX - Testing only, at least delete the "Console.WriteLine" before use. - XXXX
            IntPtr pBlob = Marshal32.ReadIntPtr(buffer, WqsOffset.lpBlob_56);
            if (pBlob != IntPtr.Zero) {
                BLOB blob = (BLOB)Marshal.PtrToStructure(pBlob, typeof(BLOB));
                if (blob.pBlobData != IntPtr.Zero) {
                    BTH_DEVICE_INFO bdi = (BTH_DEVICE_INFO)Marshal.PtrToStructure(blob.pBlobData, typeof(BTH_DEVICE_INFO));
                    BluetoothDeviceInfoProperties flags = bdi.flags;
                    Debug.WriteLine(String.Format(CultureInfo.InvariantCulture, "[BTH_DEVICE_INFO: {0:X12}, '{1}' = 0x{2:X4}]", bdi.address, flags, bdi.flags));
                    Trace.Assert((flags & ~BDIFMasks.AllOrig) == 0, "*Are* new flags there!");
                }
            }
        }
#endif

#if NETCF
        static class DevicesValueNames
        {
            internal const string DeviceName = "name";
            internal const string ClassOfDevice = "class";
        }

        private static List_IBluetoothDeviceInfo WinCEReadKnownDevicesFromRegistry()
        {
            Func<BluetoothAddress, string, uint, bool, IBluetoothDeviceInfo> makeDev
                = (address, name, classOfDevice, authd)
                    => new WindowsBluetoothDeviceInfo(address, name, classOfDevice, authd);
            var deviceListPath = "Software\\Microsoft\\Bluetooth\\Device";
            return ReadKnownDevicesFromRegistry(deviceListPath, makeDev);
        }

        internal static List_IBluetoothDeviceInfo ReadKnownDevicesFromRegistry(
            string deviceListPath, Func<BluetoothAddress, string, uint, bool, IBluetoothDeviceInfo> makeDev)
        {
            List_IBluetoothDeviceInfo known = new List_IBluetoothDeviceInfo();

            //open bluetooth device key
            RegistryKey devkey = Registry.LocalMachine.OpenSubKey(deviceListPath);
            //bool addFromRegistry = authenticated || remembered;

            if (devkey != null) {

                //enumerate the keys
                foreach (string devid in devkey.GetSubKeyNames()) {
                    BluetoothAddress address;

                    if (BluetoothAddress.TryParse(devid, out address)) {
                        //get friendly name
                        RegistryKey thisdevkey = devkey.OpenSubKey(devid);
                        string name = thisdevkey.GetValue(DevicesValueNames.DeviceName, "").ToString();
                        uint classOfDevice = Convert.ToUInt32(thisdevkey.GetValue(DevicesValueNames.ClassOfDevice, 0));
                        thisdevkey.Close();

                        //add to collection
                        IBluetoothDeviceInfo thisdevice = makeDev(address, name, classOfDevice, true);
                        known.Add(thisdevice);
                    }
                }

                devkey.Close();
            }
            return known;
        }
#endif

#if !V1
        IAsyncResult IBluetoothClient.BeginDiscoverDevices(int maxDevices,
            bool authenticated, bool remembered, bool unknown, bool discoverableOnly,
            AsyncCallback callback, object state)
        {
            return ((IBluetoothClient)this).BeginDiscoverDevices(maxDevices,
                authenticated, remembered, unknown, discoverableOnly,
                callback, state,
                null, null);
        }

        IAsyncResult IBluetoothClient.BeginDiscoverDevices(int maxDevices,
            bool authenticated, bool remembered, bool unknown, bool discoverableOnly,
            AsyncCallback callback, object state,
            InTheHand.Net.Sockets.BluetoothClient.LiveDiscoveryCallback liveDiscoHandler, object liveDiscoState)
        {
            var args = new DiscoDevsParamsWithLive(maxDevices,
                authenticated, remembered, unknown, discoverableOnly,
                DateTime.MinValue,
                liveDiscoHandler, liveDiscoState);
            AsyncResult_BeginDiscoverDevices ar = new AsyncResult_BeginDiscoverDevices(
                callback, state, args);
            System.Threading.ThreadPool.QueueUserWorkItem(BeginDiscoverDevices_Runner, ar);
            return ar;
        }

        internal class DiscoDevsParamsWithLive : DiscoDevsParams
        {
            internal readonly InTheHand.Net.Sockets.BluetoothClient.LiveDiscoveryCallback _liveDiscoHandler;
            internal readonly object _liveDiscoState;

            public DiscoDevsParamsWithLive(int maxDevices,
                    bool authenticated, bool remembered, bool unknown, bool discoverableOnly,
                    DateTime discoTime,
                    InTheHand.Net.Sockets.BluetoothClient.LiveDiscoveryCallback liveDiscoHandler, object liveDiscoState)
                : base(maxDevices,
                    authenticated, remembered, unknown, discoverableOnly,
                    discoTime)
            {
                _liveDiscoHandler = liveDiscoHandler;
                _liveDiscoState = liveDiscoState;
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
        void BeginDiscoverDevices_Runner(object state)
        {
            AsyncResult_BeginDiscoverDevices ar = (AsyncResult_BeginDiscoverDevices)state;
            ar.SetAsCompletedWithResultOf(() => DiscoverDevices(ar.BeginParameters.maxDevices,
                    ar.BeginParameters.authenticated, ar.BeginParameters.remembered,
                    ar.BeginParameters.unknown, ar.BeginParameters.discoverableOnly,
                    ar.BeginParameters._liveDiscoHandler, ar.BeginParameters._liveDiscoState), false);
        }

        IBluetoothDeviceInfo[] IBluetoothClient.EndDiscoverDevices(IAsyncResult asyncResult)
        {
            AsyncResult_BeginDiscoverDevices ar = (AsyncResult_BeginDiscoverDevices)asyncResult;
            return ar.EndInvoke();
        }
#endif

        #endregion


        #region Active
        private bool active = false;

        /// <summary>
        /// Gets or set a value that indicates whether a connection has been made.
        /// </summary>
        protected bool Active
        {
            get
            {
                return active;
            }
            set
            {
                active = value;
            }
        }
        #endregion

        #region Available
        public int Available
        {
            get
            {
                EnsureNotDisposed();
                return clientSocket.Available;
            }
        }
        #endregion

        #region Client

        private Socket clientSocket;

        public Socket Client
        {
            get { return clientSocket; }
            set { this.clientSocket = value; }

        }

        #endregion

        #region Connect
        /// <summary>
        /// Connects a client to a specified endpoint.
        /// </summary>
        /// <param name="remoteEP">A <see cref="BluetoothEndPoint"/> that represents the remote device.</param>
        public virtual void Connect(BluetoothEndPoint remoteEP)
        {
            EnsureNotDisposed();
            if (remoteEP == null) {
                throw new ArgumentNullException("remoteEP");
            }

            Connect_StartAuthenticator(remoteEP);
            try {
                var connEP = PrepareConnectEndPoint(remoteEP);
                clientSocket.Connect(connEP);
                active = true;
            } finally {
                Connect_StopAuthenticator();
            }
        }

        #region Begin Connect
        /// <summary>
        /// Begins an asynchronous request for a remote host connection.
        /// The remote host is specified by a <see cref="BluetoothEndPoint"/>. 
        /// </summary>
        /// <param name="remoteEP">A <see cref="BluetoothEndPoint"/> containing the 
        /// address and UUID of the remote service.</param>
        /// <param name="requestCallback">An AsyncCallback delegate that references the method to invoke when the operation is complete.</param>
        /// <param name="state">A user-defined object that contains information about the connect operation.
        /// This object is passed to the requestCallback delegate when the operation is complete.</param>
        /// <returns></returns>
        public virtual IAsyncResult BeginConnect(BluetoothEndPoint remoteEP, AsyncCallback requestCallback, object state)
        {
            EnsureNotDisposed();
            Connect_StartAuthenticator(remoteEP);
            var connEP = PrepareConnectEndPoint(remoteEP);
            return this.Client.BeginConnect(connEP, requestCallback, state);
        }
        #endregion

        #region End Connect
        /// <summary>
        /// Asynchronously accepts an incoming connection attempt.
        /// </summary>
        /// <param name="asyncResult">An <see cref="IAsyncResult"/> object returned by a call to 
        /// <see cref="M:BeginConnect(InTheHand.Net.Sockets.BluetoothEndPoint,System.AsyncCallback,System.Object)"/>
        /// / <see cref="M:BeginConnect(InTheHand.Net.Sockets.BluetoothAddress,System.Guid,System.AsyncCallback,System.Object)"/>.
        /// </param>
        public virtual void EndConnect(IAsyncResult asyncResult)
        {
            try {
                Socket sock = this.Client;
                if (sock == null) {
                    Debug.Assert(cleanedUp, "!cleanedUp");
                    throw new ObjectDisposedException("BluetoothClient");
                } else {
                    sock.EndConnect(asyncResult);
                }
                this.active = true;
            } finally {
                Connect_StopAuthenticator();
            }
        }
        #endregion

        #endregion

        #region Connected
        public bool Connected
        {
            get
            {
                if (clientSocket == null)
                    return false;
                return clientSocket.Connected;
            }
        }
        #endregion

        #region Get Stream

        private NetworkStream dataStream;

        protected virtual NetworkStream MakeStream(Socket sock)
        {
            return new NetworkStream(this.Client, true);
        }


        public NetworkStream GetStream()
        {
            EnsureNotDisposed();
            if (!this.Client.Connected) {
                throw new InvalidOperationException("The operation is not allowed on non-connected sockets.");
            }

            if (dataStream == null) {
                dataStream = MakeStream(this.Client);
            }

            return dataStream;
        }

#if TEST_EARLY
        public Stream GetStream2()
        {
            return GetStream();
        }
#endif
        #endregion

        public LingerOption LingerState
        {
#if !NETCF
            get { return Client.LingerState; }
            set { Client.LingerState = value; }
#else
            get
            {
                return (LingerOption)Client.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger);
            }
            set
            {
                Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, value);
            }
#endif
        }


        #region Authenticate
        /// <summary>
        /// Gets or sets the authentication state of the current connect or behaviour to use when connection is established.
        /// </summary>
        /// <remarks>
        /// For disconnected sockets, specifies that authentication is required in order for a connect or accept operation to complete successfully.
        /// Setting this option actively initiates authentication during connection establishment, if the two Bluetooth devices were not previously authenticated.
        /// The user interface for passkey exchange, if necessary, is provided by the operating system outside the application context.
        /// For outgoing connections that require authentication, the connect operation fails with WSAEACCES if authentication is not successful.
        /// In response, the application may prompt the user to authenticate the two Bluetooth devices before connection.
        /// For incoming connections, the connection is rejected if authentication cannot be established and returns a WSAEHOSTDOWN error.
        /// </remarks>
        public bool Authenticate
        {
            get { return m_optionHelper.Authenticate; }
            set { m_optionHelper.Authenticate = value; }
        }
        #endregion

        #region Encrypt
        /// <summary>
        /// On unconnected sockets, enforces encryption to establish a connection.
        /// Encryption is only available for authenticated connections.
        /// For incoming connections, a connection for which encryption cannot be established is automatically rejected and returns WSAEHOSTDOWN as the error.
        /// For outgoing connections, the connect function fails with WSAEACCES if encryption cannot be established.
        /// In response, the application may prompt the user to authenticate the two Bluetooth devices before connection.
        /// </summary>
        public bool Encrypt
        {
            get { return m_optionHelper.Encrypt; }
            set { m_optionHelper.Encrypt = value; }
        }
        #endregion


#region Link Key
        /// <summary>
        /// Returns link key associated with peer Bluetooth device.
        /// </summary>
        public Guid LinkKey
        {
            get
            {
                EnsureNotDisposed();
                byte[] bytes = new byte[16];
#if NETCF
                byte[] link = clientSocket.GetSocketOption(BluetoothSocketOptionLevel.RFComm, BluetoothSocketOptionName.GetLink, 32);
                Buffer.BlockCopy(link, 16, bytes, 0, 16);
#endif                

                return new Guid(bytes);
            }
        }

#endregion

#region Link Policy
        /// <summary>
        /// Returns the Link Policy of the current connection.
        /// </summary>
        public LinkPolicy LinkPolicy
        {
            get
            {
                EnsureNotDisposed();
#if NETCF
                byte[] policy = clientSocket.GetSocketOption(BluetoothSocketOptionLevel.RFComm, BluetoothSocketOptionName.GetLinkPolicy, 4);
                return (LinkPolicy)BitConverter.ToInt32(policy, 0);
#else
                return LinkPolicy.Disabled;
#endif
            }
        }
#endregion


#region Set PIN
        /// <summary>
        /// Sets the PIN associated with the currently connected device.
        /// </summary>
        /// <param name="pin">PIN which must be composed of 1 to 16 ASCII characters.</param>
        /// <remarks>Assigning null (Nothing in VB) or an empty String will revoke the PIN.</remarks>
        public void SetPin(string pin)
        {
            if (!Connected) {
#if WinXP
                m_pinForConnect = pin;
#else
                SetPin(null, pin);
#endif
            } else {
                EndPoint rep = clientSocket.RemoteEndPoint;
                BluetoothAddress addr = null;
                if (rep != null)
                    addr = ((BluetoothEndPoint)rep).Address;
                if (addr == null)
                    throw new InvalidOperationException(
                        "The socket needs to be connected to detect the remote device"
                        + ", use the other SetPin method..");
                SetPin(addr, pin);
            }
        }

        /// <summary>
        /// Set or change the PIN to be used with a specific remote device.
        /// </summary>
        /// <param name="device">Address of Bluetooth device.</param>
        /// <param name="pin">PIN string consisting of 1 to 16 ASCII characters.</param>
        /// <remarks>Assigning null (Nothing in VB) or an empty String will revoke the PIN.</remarks>
        public void SetPin(BluetoothAddress device, string pin)
        {
            m_optionHelper.SetPin(device, pin);
        }

        private void Connect_StartAuthenticator(BluetoothEndPoint remoteEP)
        {
#if WinXP
            if (m_pinForConnect != null) {
                SetPin(remoteEP.Address, m_pinForConnect);
            }
#endif
        }

        private void Connect_StopAuthenticator()
        {
#if WinXP
            if (m_pinForConnect != null) {
                SetPin(null, null);
            }
#endif
        }
#endregion


#region Remote Machine Name
        public BluetoothEndPoint RemoteEndPoint
        {
            get
            {
                EnsureNotDisposed();
                return (BluetoothEndPoint)clientSocket.RemoteEndPoint;
            }
        }

        /// <summary>
        /// Gets the name of the remote device.
        /// </summary>
        public string RemoteMachineName
        {
            get
            {
                EnsureNotDisposed();
                return GetRemoteMachineName(clientSocket);
            }
        }

        /// <summary>
        /// Gets the name of the specified remote device.
        /// </summary>
        /// <param name="a">Address of remote device.</param>
        /// <returns>Friendly name of specified device.</returns>
        public string GetRemoteMachineName(BluetoothAddress a)
        {
#if WinXP
            var bdi = _fcty.DoGetBluetoothDeviceInfo(a);
            return bdi.DeviceName;
#else
			byte[] buffer = new byte[504];
			//copy remote device address to buffer
			Buffer.BlockCopy(a.ToByteArray(), 0, buffer, 0, 6);

			try
			{
                clientSocket.SetSocketOption(BluetoothSocketOptionLevel.RFComm, BluetoothSocketOptionName.ReadRemoteName, buffer);
				string name = string.Empty;
                name = System.Text.Encoding.Unicode.GetString(buffer, 8, 496);
				
				int offset = name.IndexOf('\0');
				if(offset > -1)
				{
					name = name.Substring(0, offset);
				}

				return name;
			}
			catch(SocketException ex)
			{
                System.Diagnostics.Debug.WriteLine("BluetoothClient GetRemoteMachineName(addr) ReadRemoteName failed: " + ex.Message);
				return null;
			}
#endif
        }

        /// <summary>
        /// Gets the name of a device by a specified socket.
        /// </summary>
        /// <param name="s"> A <see cref="Socket"/>.</param>
        /// <returns>Returns a string value of the computer or device name.</returns>
        public static string GetRemoteMachineName(Socket s)
        {
#if WinXP
            // HACK was new WindowsBluetoothDeviceInfo
            var bdi = new BluetoothDeviceInfo(((BluetoothEndPoint)s.RemoteEndPoint).Address);
            return bdi.DeviceName;
#else
			byte[] buffer = new byte[504];
			//copy remote device address to buffer
			Buffer.BlockCopy(((BluetoothEndPoint)s.RemoteEndPoint).Address.ToByteArray(), 0, buffer, 0, 6);

            string name = "";

			try
			{
                s.SetSocketOption(BluetoothSocketOptionLevel.RFComm, BluetoothSocketOptionName.ReadRemoteName, buffer);
				name = System.Text.Encoding.Unicode.GetString(buffer, 8, 496);
				
				int offset = name.IndexOf('\0');
				if(offset > -1)
				{
					name = name.Substring(0, offset);
				}

				return name;
			}
			catch(SocketException ex)
			{
                System.Diagnostics.Debug.WriteLine("BluetoothClient GetRemoteMachineName(socket) ReadRemoteName failed: " + ex.Message);
                return null;
			}
#endif
        }
#endregion

#region IDisposable Members

        /// <summary>
        /// Releases the unmanaged resources used by the BluetoothClient and optionally releases the managed resources.
        /// </summary>
        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (!cleanedUp) {
                if (disposing) {
                    IDisposable idStream = dataStream;
                    if (idStream != null) {
                        //dispose the stream which will also close the socket
                        idStream.Dispose();
                    } else {
                        if (this.Client != null) {
                            this.Client.Close();
                            this.Client = null;
                        }
                    }
                    // TODO ??? m_optionHelper.Dispose();
                }

                cleanedUp = true;
            }
        }

        private void EnsureNotDisposed()
        {
            Debug.Assert(cleanedUp == (clientSocket == null), "always consistent!! ("
                + cleanedUp + " != " + (clientSocket == null) + ")");
            if (cleanedUp || (clientSocket == null))
                throw new ObjectDisposedException("BluetoothClient");
        }

        /// <summary>
        /// Closes the <see cref="BluetoothClient"/> and the underlying connection.
        /// </summary>
        /// -
        /// <seealso cref="M:InTheHand.Net.Sockets.BluetoothClient.Close"/>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Frees resources used by the <see cref="BluetoothClient"/> class.
        /// </summary>
        ~SocketBluetoothClient()
        {
            Dispose(false);
        }

#endregion

#region Throw SocketException For HR
        internal static void ThrowSocketExceptionForHR(int errorCode)
        {
            if (errorCode < 0) {
                int socketerror = 0;
                socketerror = Marshal.GetLastWin32Error();

                throw new SocketException(socketerror);
            }
        }

        internal static void ThrowSocketExceptionForHrExceptFor(int errorCode, params int[] nonErrorCodes)
        {
            if (errorCode < 0) {
                int socketerror = 0;
                socketerror = Marshal.GetLastWin32Error();
                if (-1 != Array.IndexOf(nonErrorCodes, socketerror, 0, nonErrorCodes.Length)) {
                    return;
                }
                throw new SocketException(socketerror);
            }
        }
#endregion

        internal class MsftSocketOptionHelper : ISocketOptionHelper
        {
            readonly Socket m_socket;
#if !WinCE
            private bool authenticate = false;
            private BluetoothWin32Authentication m_authenticator;
#endif
            private bool encrypt = false;

            internal MsftSocketOptionHelper(Socket socket)
            {
                m_socket = socket;
            }

#region Authenticate
            /// <summary>
            /// Gets or sets the authentication state of the current connect or behaviour to use when connection is established.
            /// </summary>
            /// <remarks>
            /// For disconnected sockets, specifies that authentication is required in order for a connect or accept operation to complete successfully.
            /// Setting this option actively initiates authentication during connection establishment, if the two Bluetooth devices were not previously authenticated.
            /// The user interface for passkey exchange, if necessary, is provided by the operating system outside the application context.
            /// For outgoing connections that require authentication, the connect operation fails with WSAEACCES if authentication is not successful.
            /// In response, the application may prompt the user to authenticate the two Bluetooth devices before connection.
            /// For incoming connections, the connection is rejected if authentication cannot be established and returns a WSAEHOSTDOWN error.
            /// </remarks>
            public bool Authenticate
            {
                get
                {
#if NETCF
                    byte[] authbytes = m_socket.GetSocketOption(BluetoothSocketOptionLevel.RFComm, BluetoothSocketOptionName.GetAuthenticationEnabled, 4);
                    int auth = BitConverter.ToInt32(authbytes, 0);
                    return (auth==0) ? false : true;
#else
                    return authenticate;
#endif
                }
                set
                {
#if NETCF
                    m_socket.SetSocketOption(BluetoothSocketOptionLevel.RFComm, BluetoothSocketOptionName.SetAuthenticationEnabled, (int)(value ? 1 : 0));
#else
                    m_socket.SetSocketOption(BluetoothSocketOptionLevel.RFComm, BluetoothSocketOptionName.Authenticate, value);
                    authenticate = value;
#endif
                }
            }
#endregion

#region Encrypt
            /// <summary>
            /// On unconnected sockets, enforces encryption to establish a connection.
            /// Encryption is only available for authenticated connections.
            /// For incoming connections, a connection for which encryption cannot be established is automatically rejected and returns WSAEHOSTDOWN as the error.
            /// For outgoing connections, the connect function fails with WSAEACCES if encryption cannot be established.
            /// In response, the application may prompt the user to authenticate the two Bluetooth devices before connection.
            /// </summary>
            public bool Encrypt
            {
                get { return encrypt; }
                set
                {
                    m_socket.SetSocketOption(BluetoothSocketOptionLevel.RFComm, BluetoothSocketOptionName.Encrypt, (int)(value ? 1 : 0));
                    encrypt = value;
                }
            }
#endregion

#region Set Pin
            public void SetPin(BluetoothAddress device, string pin)
            {
#if WinXP
                if (pin != null) {
                    m_authenticator = new BluetoothWin32Authentication(device, pin);
                } else {
                    if (m_authenticator != null) {
                        m_authenticator.Dispose();
                    }
                }
#else
                byte[] link = new byte[32];

                //copy remote device address
                if (device != null)
                {
                    Buffer.BlockCopy(device.ToByteArray(), 0, link, 8, 6);
                }

                //copy PIN
                if (pin != null & pin.Length > 0)
                {
                    if (pin.Length > 16)
                    {
                        throw new ArgumentOutOfRangeException("PIN must be between 1 and 16 ASCII characters");
                    }
                    //copy pin bytes
                    byte[] pinbytes = System.Text.Encoding.ASCII.GetBytes(pin);
                    Buffer.BlockCopy(pinbytes, 0, link, 16, pin.Length);
                    BitConverter.GetBytes(pin.Length).CopyTo(link, 0);
                }

                m_socket.SetSocketOption(BluetoothSocketOptionLevel.RFComm, BluetoothSocketOptionName.SetPin, link);
#endif
            }
#endregion

        }//class--SocketOptionHelper

    }//class--BluetoothClient

}