//-----------------------------------------------------------------------
// <copyright file="DynamicLocater.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.
 */

//// Implementation needs to be changed to support old version (pre 04.04) of J2534.
//// #define SUPPORT_OLD_J2534

namespace DynamicApiLoading.Api.Dynamic
{
    using System;
    using System.Collections.Generic;
    using global::Microsoft.Win32;

    /// <summary>
    /// Class that locates J2534 DLLs by searching the registry together with their supported options.
    /// </summary>
    public class DynamicLocater
    {
        /// <summary>
        /// Protocol name filter values.
        /// </summary>
        private static List<string> protocolNames = new List<string>()
        {
            "J1850PWM",
            "J1850VPW",
            "ISO9141",
            "ISO14230",
            "ISO15765",
            "CAN",
        };

        /// <summary>
        /// List of encountered drivers.
        /// </summary>
        private List<DynamicAdapter> adapterList = new List<DynamicAdapter>();

        /// <summary>
        /// Gets list of encountered drivers.
        /// </summary>
        public IList<DynamicAdapter> adapters
        {
            get
            {
                return this.adapterList;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DynamicLocater" /> class.
        /// </summary>
        public DynamicLocater()
        {
            RegistryKey key = Registry.LocalMachine;
            RegistryKey swKey = key.OpenSubKey("SOFTWARE");
            this.recursiveLookup(swKey);
        }

        /// <summary>
        /// Get a string representation of the object.
        /// </summary>
        /// <returns>String presenting object data.</returns>
        public override string ToString()
        {
            string txt = string.Empty;
            foreach (DynamicAdapter adapter in this.adapterList)
            {
                txt += "Adapter: " + adapter.ToString() + "\r\n";
            }

            return txt;
        }

        /// <summary>
        /// Fetch a list of supported protocols for the device driver.
        /// </summary>
        /// <param name="vendorDeviceRk">Registry key for device driver.</param>
        /// <returns>List of protocols supported.</returns>
        private static IList<string> getSupportedProtocols(RegistryKey vendorDeviceRk)
        {
            string protocolsSupportedStr = getStringValue(vendorDeviceRk, "ProtocolsSupported");
            SortedDictionary<string, string> sortedProtocols = new SortedDictionary<string, string>();
            string[] valueNames;
            if (protocolsSupportedStr != null)
            {
                valueNames = protocolsSupportedStr.Split(new char[] { ',' });
            }
            else
            {
                valueNames = vendorDeviceRk.GetValueNames();
            }

            foreach (string valueName in valueNames)
            {
                string trimmedValueName = valueName.Trim();
                if (protocolNames.Contains(trimmedValueName) && !sortedProtocols.ContainsKey(trimmedValueName))
                {
                    sortedProtocols.Add(trimmedValueName, trimmedValueName);
                }
            }

            IList<string> protocols = new List<string>();
            foreach (KeyValuePair<string, string> kvp in sortedProtocols)
            {
                protocols.Add(kvp.Key);
            }

            return protocols;
        }

        /// <summary>
        /// Get a value in string form from the registry.
        /// </summary>
        /// <param name="vendorDeviceRk">Registry key for device driver.</param>
        /// <param name="name">Value name</param>
        /// <returns>String value</returns>
        private static string getStringValue(RegistryKey vendorDeviceRk, string name)
        {
            string value = null;
            try
            {
                if (vendorDeviceRk.GetValueKind(name) == RegistryValueKind.String)
                {
                    value = (string)vendorDeviceRk.GetValue(name);
                }
            }
            catch (Exception ex)
            {
                if (ex != null)
                {
                    // this.iLogging.appendText("getStringValue(" + name + "):" + ex.Message + "\r\n", LogLevel.LOG_DEBUG);
                }
            }

            return value;
        }

        /// <summary>
        /// Get a value in int form from the registry.
        /// <para>
        /// Notice: The returned value may be 'null' if the value doesn't exist.
        /// </para>
        /// </summary>
        /// <param name="vendorDeviceRk">Registry key for device driver.</param>
        /// <param name="name">Value name</param>
        /// <returns>int value</returns>
        private static int? getIntValue(RegistryKey vendorDeviceRk, string name)
        {
            int? value = null;
            try
            {
                if (vendorDeviceRk.GetValueKind(name) == RegistryValueKind.DWord)
                {
                    object obj = vendorDeviceRk.GetValue(name);
                    if (obj is int)
                    {
                        value = (int)obj;
                    }
                }
            }
            catch (Exception ex)
            {
                if (ex != null)
                {
                    // this.iLogging.appendText("getIntValue(" + name + "):" + ex.Message + "\r\n", LogLevel.LOG_DEBUG);
                }
            }

            return value;
        }

        /// <summary>
        /// Do a recursive lookup.
        /// <para>
        /// This is used since some registry keys are located in sub-locations depending
        /// on if it's a 64-bit or 32-bit OS.
        /// </para>
        /// </summary>
        /// <param name="swRk">Registry key 'SOFTWARE'</param>
        private void recursiveLookup(RegistryKey swRk)
        {
            string[] subkeys = swRk.GetSubKeyNames();

            foreach (string keyName in subkeys)
            {
                switch (keyName)
                {
                    case "PassThruSupport":
#if SUPPORT_OLD_J2534
                        this.locateOldDevices(swRk, keyName);
#endif
                        break;
                    case "PassThruSupport.04.04":
                        this.locateDevices(swRk, keyName);
                        break;
                    case "Wow6432Node":
                        this.nextLevel(swRk, keyName);
                        break;
                    default:
                        break;
                }
            }
        }

#if SUPPORT_OLD_J2534
        /// <summary>
        /// Locate old J2534 drivers.
        /// <para>
        /// These drivers have a bit of a different API and
        /// needs to be called a bit differently.
        /// </para>
        /// </summary>
        /// <param name="swRk">Registry key 'SOFTWARE'</param>
        /// <param name="keyName">Name of key.</param>
        private void locateOldDevices(RegistryKey swRk, string keyName)
        {
            RegistryKey passthruRk = swRk.OpenSubKey(keyName);
            string[] vendorkeys = passthruRk.GetSubKeyNames();
            foreach (string vendorkey in vendorkeys)
            {
                RegistryKey vendorRk = passthruRk.OpenSubKey(vendorkey);
                string vendor = this.getStringValue(vendorRk, "Name");
                RegistryKey vendorDevicesRk = vendorRk.OpenSubKey("Devices");
                string[] devicesKeys = vendorDevicesRk.GetSubKeyNames();

                foreach (string deviceKey in devicesKeys)
                {
                    RegistryKey vendorDeviceRk = vendorDevicesRk.OpenSubKey(deviceKey);
                    this.addDriver(true, vendor, vendorDeviceRk, deviceKey);
                }
            }
        }
#endif

        /// <summary>
        /// Locate J2534 devices supporting the 04.04 version of the API.
        /// </summary>
        /// <param name="swRk">Registry key 'SOFTWARE'</param>
        /// <param name="keyName">Name of key.</param>
        private void locateDevices(RegistryKey swRk, string keyName)
        {
            RegistryKey passthruRk = swRk.OpenSubKey(keyName);
            string[] devicesKeys = passthruRk.GetSubKeyNames();

            foreach (string deviceKey in devicesKeys)
            {
                RegistryKey vendorDeviceRk = passthruRk.OpenSubKey(deviceKey);

                if (vendorDeviceRk != null)
                {
                    string vendor = getStringValue(vendorDeviceRk, "Vendor");

                    this.addDriver(false, vendor, vendorDeviceRk, deviceKey);
                }
            }
        }

        /// <summary>
        /// Add one driver to the list of found drivers.
        /// </summary>
        /// <param name="oldDriver">'true' if not 04.04 version.</param>
        /// <param name="vendor">Name of vendor.</param>
        /// <param name="vendorDeviceRk">Registry key for vendor device.</param>
        /// <param name="deviceKey">Key string for device.</param>
        private void addDriver(bool oldDriver, string vendor, RegistryKey vendorDeviceRk, string deviceKey)
        {
            string name = getStringValue(vendorDeviceRk, "Name");
            string logfile = getStringValue(vendorDeviceRk, "Logfile2534");
            string configApplication = getStringValue(vendorDeviceRk, "ConfigApplication");
            string j2534dll = getStringValue(vendorDeviceRk, "FunctionLibrary");
            string rp1210Library = getStringValue(vendorDeviceRk, "RP1210Library");
            int? rp1210DeviceId = getIntValue(vendorDeviceRk, "RP1210DeviceId");

            IList<string> protocols = getSupportedProtocols(vendorDeviceRk);

            DynamicAdapter da = new DynamicAdapter(
                oldDriver,
                deviceKey,
                name,
                vendor,
                logfile,
                configApplication,
                j2534dll,
                rp1210Library,
                rp1210DeviceId,
                protocols);

            this.adapterList.Add(da);
        }

        /// <summary>
        /// Step to next level in lookup.
        /// </summary>
        /// <param name="key">Base registry key.</param>
        /// <param name="keyName">Name of sub-key.</param>
        private void nextLevel(RegistryKey key, string keyName)
        {
            RegistryKey key1 = key.OpenSubKey(keyName);
            if (key1 != null)
            {
                this.recursiveLookup(key1);
            }
        }
    }
}