using Biesse.ScriptTuning;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;

namespace Biesse.PlantConfigurator.Core.SxData.SxParameterEdit
{
    [Serializable]
#pragma warning disable CS0659 // Type overrides Object.Equals(object o) but does not override Object.GetHashCode()
    public abstract class ParameterEdit : ISerializable
#pragma warning restore CS0659 // Type overrides Object.Equals(object o) but does not override Object.GetHashCode()
    {
        protected ParameterEdit() { }

        protected ParameterEdit(SerializationInfo info, StreamingContext context)
        {
            try
            {
                bool IsJson = false;
                foreach (SerializationEntry entry in info)
                {
                    if (entry.ObjectType.ToString().Contains("Json"))
                    {
                        IsJson = true;
                        break;
                    }
                }

                if (IsJson)
                {
                    CanRaiseModified = info.GetBoolean(nameof(CanRaiseModified));
                    IsCustomized = info.GetBoolean(nameof(IsCustomized));
                }
                else
                {
                    CanRaiseModified = Misc.TryGetSerializedVariableValue(info, nameof(CanRaiseModified),
                    () => Misc.TryGetSerializedVariableValue(info, "ParameterEdit+<CanRaiseModified>k__BackingField",
                        () => true));
                    IsCustomized = Misc.TryGetSerializedVariableValue(info, nameof(IsCustomized),
                        () => Misc.TryGetSerializedVariableValue(info, "ParameterEdit+<IsCustomized>k__BackingField",
                            () => true));
                    //CanRaiseModified = info.GetBoolean(nameof(CanRaiseModified));
                    //IsCustomized = info.GetBoolean(nameof(IsCustomized));
                }
            }
            catch (Exception e)
            {
                Configuratore.Logger.Error(e);
                throw;
            }
        }

        public static readonly string ArgsSeparator = "  ";
        public static readonly string ArgsDBSeparator = "\r\n";
        public static readonly string ListSeparator = ";";
        private static readonly string ClassNameSuffix = "ParameterEdit";

        /// <summary>
        /// Definisce le corrispondenze tra gli acronimi utilizzati dai file stb e le proprietà dei vari oggetti ParameterEdit in modo da disaccoppiare i due nomi.
        /// La Key è l'acronimo, mentre Value è il nome della proprietà dell'oggetto ParameterEdit.
        /// </summary>
        protected virtual Dictionary<string, string> TokenToProperty => new(StringComparer.Ordinal);

        public bool CanRaiseModified { get; set; }

        public bool IsCustomized { get; set; }

        protected bool IsReadOnly => false;

        protected void OnModified()
        {
            IsCustomized = true;
        }

        protected string BuildArgField(string propertyName, string value)
        {
            string key = PropertyToToken(propertyName);

            if (key == default)
                key = propertyName;

            return key + "=" + value;
        }

        public static IParameterEdit CreateInstance(string peName, SxField element)
        {
            var methodInfo = MethodBase.GetCurrentMethod();
            Type peType = Type.GetType(methodInfo.DeclaringType.Namespace + "." + peName + ClassNameSuffix);
            if (peType != null)
            {
                try
                {
                    return (IParameterEdit)Activator.CreateInstance(peType, new object[] { element });
                }
                catch (Exception ex)
                {
                    throw new Exception($"Errore instanziando il ParameterEdit {peName}: {ex.Message}");
                }
            }
            else
                throw new Exception($"{peName}: Tipo di ParameterEdit non riconosciuto.");
        }

        protected abstract bool CustomEquals(object obj);

        internal string PropertyToToken(string propertyName)
        {
            string result = TokenToProperty.FirstOrDefault(x => x.Value == propertyName).Key;

            if (result == default)
                result = propertyName;

            return result;
        }

#pragma warning disable CS0659
        public override bool Equals(object obj)
#pragma warning restore CS0659
        {
            if (obj == null || GetType() != obj.GetType())
                return false;

            return CustomEquals(obj);
        }

        public virtual string Args => string.Empty;

        public abstract ParameterTypes ParameterType { get; }

        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue(nameof(CanRaiseModified), CanRaiseModified);
            info.AddValue(nameof(IsCustomized), IsCustomized);
        }

        private class Misc
        {
            /// <summary>
            /// Tenta di recuperare la variabile. Se la variabile non è stata serializzata, richiama
            /// il costruttore di default per inizializzarla
            /// </summary>
            /// <param name="info"></param>
            /// <param name="variableName"></param>
            /// <param name="defaultConstructor">delegato al costruttore di default della variabile</param>
            /// <returns>variabile richiesta. Se è presente nella serializzazione il suo valore, 
            /// altrimenti il valore di default data dal costruttore di default</returns>
            public static T TryGetSerializedVariableValue<T>(SerializationInfo info, string variableName,
                Func<T> defaultConstructor)
            {
                foreach (SerializationEntry entry in info)
                {
                    if (entry.Name.Equals(variableName))
                        return (T)entry.Value;
                }
                return defaultConstructor();
            }
        }
    }
}