//            Copyright Keysight Technologies 2012-2019
// 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/.
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;

namespace OpenTap
{
    /// <summary>
    /// Utility class for SCPI communication.
    /// </summary>
    public static class Scpi
    {
        /// <summary>
        /// Enum converter for converting Enums to SCPI strings. use the GetEnumConv to get a converter.
        /// </summary>
        class ScpiEnum
        {
            // Remembers how to convert types.
            static readonly ConcurrentDictionary<Type, ScpiEnum> converters = new ConcurrentDictionary<Type, ScpiEnum>();

            /// <summary> Get an enum converter for a specific enum type. </summary>
            /// <param name="t">Must be a enum type!</param>
            /// <returns></returns>
            public static ScpiEnum GetEnumConv(Type t)
            {
                return converters.GetOrAdd(t, t2 => new ScpiEnum(t2));
            }

            readonly ImmutableDictionary<string, Enum> convertBack;
            readonly ImmutableDictionary<Enum, string> convert;

            /// <summary> String to Enum. </summary>
            /// <param name="input"></param>
            /// <returns></returns>
            public Enum FromString(string input)
            {
                return convertBack[input];
            }

            /// <summary>
            /// Enum to string.
            /// </summary>
            /// <param name="item"></param>
            /// <returns></returns>
            public string ToString(Enum item)
            {
                return convert[item];
            }

            ScpiEnum(Type type)
            {
                // collect enum values and string conversions.
                var enumValues = Enum.GetValues(type);
                
                var enum2String = new Dictionary<Enum, string>();
                var string2Enum = new Dictionary<string, Enum>();
                foreach (Enum val in enumValues)
                {
                    var member = type.GetMember(val.ToString())[0];
                    var scpiName = member.GetCustomAttribute<ScpiAttribute>()?.ScpiString ?? val.ToString();
                    enum2String[val] = scpiName;
                    string2Enum[scpiName] = val;
                }

                convert = enum2String.ToImmutableDictionary();
                convertBack = string2Enum.ToImmutableDictionary();
            }
        }

        static string valueToScpiString(object propertyValue)
        {
            var type = propertyValue.GetType();
            string value;
            if (type == typeof(bool))
            {
                value = (bool)propertyValue ? "ON" : "OFF";
            }
            else if (type.IsEnum)
            {
                value = ScpiEnum.GetEnumConv(type).ToString((Enum)propertyValue);
            }
            else if (type.IsArray)
            {
                var Props = (Array)propertyValue;

                string[] PropStrings = new string[Props.Length];
                for (int i = 0; i < Props.Length; i++)
                    PropStrings[i] = valueToScpiString(Props.GetValue(i));

                value = string.Join(",", PropStrings);
            }
            else
            {
                value = Convert.ToString(propertyValue, CultureInfo.InvariantCulture);
            }

            return value;
        }

        /// <summary>
        /// Similar to <see cref="string.Format(string,object[])"/>, but makes args SCPI compatible. Bools are ON/OFF formatted. Enum values uses <see cref="ScpiAttribute.ScpiString"/>.
        /// Arrays will have their elements formatted and separated by commas if available; if not they are converted using <see cref="string.ToString()"/>.
        /// </summary>
        /// <param name="command"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public static string Format(string command, params object[] args)
        {
            if (command == null)
                throw new ArgumentNullException("command");
            if (args == null)
                throw new ArgumentNullException("args");
            string[] stringArgs = new string[args.Length];
            for (int i = 0; i < args.Length; i++)
            {
                stringArgs[i] = args[i] == null ? "" : valueToScpiString(args[i]);
            }
            return string.Format(command, stringArgs);
        }

        /// <summary>
        /// Extension method that checks whether a given char is a IEEE488.2 whitespace (7.4.1.2).
        /// </summary>
        private static bool IsScpiWhitespace(this char c)
        {
            return (
                ((((int)c) >= 0) && (((int)c) <= 9)) ||
                ((((int)c) >= 11) && (((int)c) <= 32))
            );
        }

        private static int FindStringEnd(string Resp, int Start)
        {
            int stop = Resp.IndexOf("\"", Start + 1);

            if (stop < 0)
                return -1;
            // Skip inserted quotes
            while ((stop < (Resp.Length - 1)) && (Resp.Substring(stop, 2) == "\"\""))
            {
                stop = Resp.IndexOf("\"", stop + 2);
                if (stop < 0)
                    return -1;
            }

            return stop;
        }

        /// <summary>
        /// Splits a string into a list of valid separated SCPI response data strings. Needed because String.Split(resp, ',') is not tolerant to " characters.
        /// </summary>
        private static List<string> SplitScpiArray(string resp, bool ThrowIfInvalid = false)
        {
            List<string> result = new List<string>();

            int start = 0;
            int stop = 0;

            while (start < (resp.Length - 1))
            {
                // Trim whitespace from the start of the string
                char c = resp[start];
                while (c.IsScpiWhitespace())
                    c = resp[++start];
                stop = start;

                // Test if the next character is a string quote
                if (c == '"')
                {
                    stop = FindStringEnd(resp, stop);

                    if (stop < 0)
                    {
                        if (ThrowIfInvalid) throw new Exception(string.Format("Unterminated SCPI response: '{0}'", resp));
                        stop = resp.Length;
                    }
                    else
                        stop++;

                    result.Add(resp.Substring(start, stop - start));

                    stop = resp.IndexOf(",", stop);
                    if (stop < 0)
                        stop = resp.Length;
                    start = stop + 1;
                }
                else
                {
                    stop = resp.IndexOf(",", start);

                    if (stop < 0)
                        stop = resp.Length;

                    result.Add(resp.Substring(start, stop - start));
                    start = stop + 1;
                }
            }
            if (start < resp.Length)
                result.Add(resp.Substring(start));
            return result;
        }

        /// <summary>
        /// Overloaded.  Parses the result of a SCPI query back to T, with special parsing for enums, bools and arrays. Bools support 1/0 and ON/OFF formats. 
        /// If Enums are tagged with <see cref="ScpiAttribute"/>, <see cref="ScpiAttribute.ScpiString"/> will be used instead of <see cref="string.ToString()"/> .  
        /// </summary>
        /// <param name="scpiString"></param>
        /// <param name="T"></param>
        /// <returns></returns>
        public static object Parse(string scpiString, Type T)
        {
            if (scpiString == null)
                throw new ArgumentNullException("scpiString");
            if (T == null)
                throw new ArgumentNullException("T");
            scpiString = scpiString.Trim(); // Ensure no garbage.
            if (T == typeof(bool))
            {
                return scpiString == "ON" || scpiString == "1";
            }
            else if (T.IsEnum)
            {
                return (object)ScpiEnum
                    .GetEnumConv(T)
                    .FromString(scpiString);
            }
            else if (T.IsArray)
            {
                List<string> elements = SplitScpiArray(scpiString);
                Array result = Array.CreateInstance(T.GetElementType(), elements.Count);

                for (int i = 0; i < elements.Count; i++)
                    result.SetValue(Parse(elements[i], T.GetElementType()), i);

                return result;
            }

            return Convert.ChangeType(scpiString, T, CultureInfo.InvariantCulture);
        }

        /// <summary>
        /// Parses the result of a SCPI query back to T. Special parsing for enums, bools and arrays. bools supports 1/0 and ON/OFF formats. 
        /// If Enums are tagged with <see cref="ScpiAttribute"/> <see cref="ScpiAttribute.ScpiString"/> will be used instead of <see cref="string.ToString()"/>.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="scpiString"></param>
        /// <returns></returns>
        public static T Parse<T>(string scpiString)
        {
            return (T)Parse(scpiString, typeof(T));
        }

        /// <summary>
        /// <see cref="GetUnescapedScpi"/>.
        /// </summary>
        /// <param name="src"></param>
        /// <param name="ScpiString"></param>
        /// <param name="property"></param>
        /// <returns></returns>
        static string getUnescapedScpi(object src, string ScpiString, PropertyInfo property)
        {

            if (ScpiString.Contains("%"))
            {
                string value;
                object propertyValue = property.GetValue(src, null);
                if (propertyValue == null)
                    return ScpiString;
                value = valueToScpiString(propertyValue);

                return ScpiString.Replace("%", value);
            }

            if (property.PropertyType == typeof(bool) && ScpiString.Contains("|"))
            {
                Regex rx = new Regex(".* (?<true>[^|]+)\\|(?<false>[^\\s]+)");
                Match m = rx.Match(ScpiString);
                if (m.Success)
                {
                    bool value = (bool)property.GetValue(src, null);
                    if (value == true)
                        return ScpiString.Replace("|" + m.Groups["false"], "");
                    else
                        return ScpiString.Replace(m.Groups["true"] + "|", "");
                }
            }
            return ScpiString;
        }
        /// <summary>
        /// Parses one or more items of <see cref="ScpiAttribute.ScpiString"/> 'property', replacing '%' with the value of the property given after formatting. 
        /// Note that 'property' must be a property with the <see cref="ScpiAttribute"/>, and 'src' is the object containing 'property', not the value of the property. 
        /// If property.PropertyType is bool, then from the <see cref="ScpiAttribute.ScpiString"/> value 'A|B' A is selected if true, and B is selected if false.  
        /// </summary>
        public static string[] GetUnescapedScpi(object src, PropertyInfo property)
        {
            if (property == null)
                throw new ArgumentNullException("property");
            var scpiStrings = property.GetCustomAttributes<ScpiAttribute>().Select(scpiAttr => scpiAttr.ScpiString);
            return scpiStrings.Select(str => getUnescapedScpi(src, str, property)).ToArray();
        }
    }
}