using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;

namespace OpenTap.Plugins.BasicSteps
{
    class ExpandedMemberData : IMemberData, IParameterMemberData, IDynamicMemberData
    {
        public override bool Equals(object obj)
        {
            if (obj is ExpandedMemberData mem)
            {
                return object.Equals(mem.DeclaringType, DeclaringType) && object.Equals(mem.Name, Name);
            }

            return false;
        }

        public override int GetHashCode() =>  DeclaringType.GetHashCode() * 12389321 + Name.GetHashCode() * 7310632;

        public ITypeData DeclaringType { get; set; }

        public IEnumerable<object> Attributes { get; private set; }

        public string Name { get; set; }

        public bool Writable => true;

        public bool Readable => true;

        public ITypeData TypeDescriptor { get; set; }

        public object GetValue(object owner)
        {
            var tpr = owner as TestPlanReference;
            var ep = tpr.ExternalParameters.FirstOrDefault(x => x.Name == epName);

            var Member = ep.ParameterizedMembers.First().Member;
            TypeDescriptor = Member.TypeDescriptor;
            return ep.GetValue(tpr.plan);
        }

        public  ParameterMemberData ExternalParameter
        {
            get
            {
                var tpr = (this.DeclaringType as ExpandedTypeData).Object;
                var ep = tpr.ExternalParameters.FirstOrDefault(x => x.Name == epName);
                return ep;
            }
        }

        string epName;

        public void SetValue(object owner, object value)
        {
            var tpr = owner as TestPlanReference;
            var ep = tpr.ExternalParameters.FirstOrDefault(x => x.Name == epName);
            var Member = ep.ParameterizedMembers.First().Member;
            TypeDescriptor = Member.TypeDescriptor;
            ep.SetValue(tpr.plan, value);
        }

        public ExpandedMemberData(ParameterMemberData ep, string name)
        {
            Name = name;
            var Member = ep.ParameterizedMembers.First().Member;
            
            epName = ep.Name;
            TypeDescriptor = Member.TypeDescriptor;
            var attrs = Member.Attributes.ToList();
            attrs.RemoveIf<object>(x => x is DisplayAttribute);
            
            var dis = ep.Attributes.OfType<DisplayAttribute>().FirstOrDefault();
            if (dis == null)
                dis = Member.GetDisplayAttribute();
            
            attrs.Add(new DisplayAttribute(dis.Name, Description: dis.Description, Order: 5, Groups:dis.Group));
            static bool FilterAttributes(object attr)
            {
                switch (attr)
                {
                    case ColumnDisplayNameAttribute: return false;
                    case ExternalParameterAttribute: return false;
                    default: return true;
                }
            }
            attrs.RemoveIf<object>(static x => FilterAttributes(x) == false);


            Attributes = attrs;
        }

        public IEnumerable<(object, IMemberData)> ParameterizedMembers =>
            ExternalParameter.ParameterizedMembers
                .Select(x => new KeyValuePair<ITestStep, IEnumerable<IMemberData>>((ITestStep)x.Source, new []{x.Member}))
                .SelectMany(x => x.Value.Select(y => ((object)x.Key, y)));
        
        /// <summary> Set to true if the member has been removed from the test plan reference.</summary>
        public bool IsDisposed => ExternalParameter == null || ParameterizedMembers.Any() == false;
    }

    class ExpandedTypeData : ITypeData
    {
        private static readonly Regex propRegex = new Regex(@"^prop(?<index>[0-9]+)$", RegexOptions.Compiled);

        public override bool Equals(object obj)
        {
            if (obj is ExpandedTypeData exp)
                return exp.Object == Object;
            return false;
        }

        public override int GetHashCode() => Object.GetHashCode() ^ 0x1111234;

        public ITypeData InnerDescriptor;
        public TestPlanReference Object;

        public string Name => ExpandMemberDataProvider.exp + InnerDescriptor.Name;

        public IEnumerable<object> Attributes => InnerDescriptor.Attributes;

        public ITypeData BaseType => InnerDescriptor;

        public bool CanCreateInstance => InnerDescriptor.CanCreateInstance;

        public object CreateInstance(object[] arguments)
        {
            return InnerDescriptor.CreateInstance(arguments);
        }

        private IMemberData ResolveLegacyName(string memberName)
        {
            ExpandedMemberData result = null; // return null if no valid expanded member data gets set

            // The following code is only for legacy purposes where properties which were not valid would get a valid 
            // name like: prop0, prop1, prop73, where the number after the prefix prop would be the actual index in the
            // ForwardedParameters array.
            Match m = propRegex.Match(memberName);
            if (m.Success)
            {
                int index = 0;
                try
                {
                    index = int.Parse(m.Groups["index"].Value);
                    if (index >= 0 && index < Object.ExternalParameters.Length)
                    {
                        var ep = Object.ExternalParameters[index];
                        // return valid expanded member data
                        result = new ExpandedMemberData(ep, ep.Name) {DeclaringType = this};
                    }
                }
                catch
                {
                }
            }

            return result;
        }

        public IMemberData GetMember(string memberName)
        {
            var mem = GetMembers().FirstOrDefault(x => x.Name == memberName);
            return mem ?? ResolveLegacyName(memberName);
        }

        string names = "";
        IMemberData[] savedMembers = null;

        public IEnumerable<IMemberData> GetMembers()
        {
            if (Object == null) // this can occur during deserialization
                return InnerDescriptor.GetMembers();
            var names2 = string.Join(",", Object.ExternalParameters.Select(x => x.Name));
            if (names == names2 && savedMembers != null) return savedMembers;
            List<IMemberData> members = new List<IMemberData>();

            for (int i = 0; i < Object.ExternalParameters.Length; i++)
            {
                var ep = Object.ExternalParameters[i];
                members.Add(new ExpandedMemberData(ep, ep.Name) {DeclaringType = this});
            }

            var innerMembers = InnerDescriptor.GetMembers();
            foreach (var mem in innerMembers)
                members.Add(mem);
            savedMembers = members.ToArray();
            names = names2;
            return members;
        }
        
    }


    public class ExpandMemberDataProvider : ITypeDataProvider
    {
        public double Priority => 1;
        internal const string exp = "ref@";

        public ITypeData GetTypeData(string identifier)
        {
            if (identifier.StartsWith(exp))
            {
                var tp = TypeData.GetTypeData(identifier.Substring(exp.Length));
                if (tp != null)
                {
                    return new ExpandedTypeData() {InnerDescriptor = tp, Object = null};
                }
            }

            return null;
        }

        static ConditionalWeakTable<TestPlanReference, ExpandedTypeData> types =
            new ConditionalWeakTable<TestPlanReference, ExpandedTypeData>();

        ExpandedTypeData getExpandedTypeData(TestPlanReference step)
        {
            var expDesc = new ExpandedTypeData();
            expDesc.InnerDescriptor = TypeData.FromType(typeof(TestPlanReference));
            expDesc.Object = step;
            return expDesc;
        }

        
        static ConditionalWeakTable<SweepParameterStep, SweepRowTypeData> sweepRowTypes =
            new ConditionalWeakTable<SweepParameterStep, SweepRowTypeData>();
        
        public ITypeData GetTypeData(object obj)
        {
            if (obj is TestPlanReference exp)
                return types.GetValue(exp, getExpandedTypeData);
            
            if (obj is SweepRow row && row.Loop != null)
                return sweepRowTypes.GetValue(row.Loop, e => new SweepRowTypeData(e));
            
            return null;
        }
    }

    class SweepRowMemberData : IMemberData, IParameterMemberData
    {
        SweepRowTypeData declaringType;
        IMemberData innerMember;
        public SweepRowMemberData(SweepRowTypeData declaringType, IMemberData innerMember)
        {
            this.declaringType = declaringType;
            this.innerMember = innerMember;
            ParameterizedMembers = new (object, IMemberData)[]{(declaringType.SweepParameterLoop, innerMember)};
        }

        public IEnumerable<object> Attributes => innerMember.Attributes;
        public string Name => innerMember.Name;
        public ITypeData DeclaringType => declaringType;
        public ITypeData TypeDescriptor => innerMember.TypeDescriptor;
        public bool Writable => innerMember.Writable;
        public bool Readable => innerMember.Readable;
        public void SetValue(object owner, object value)
        {
            var own = (SweepRow)owner;
            own.Values[Name] = cloneIfPossible(value, own.Loop);
        }

        public object GetValue(object owner)
        {
            var own = (SweepRow)owner;
            if(own.Values.TryGetValue(Name, out var value))
                return value;
            var newv = cloneIfPossible(this.innerMember.GetValue(owner), own.Loop);
            own.Values[Name] = newv;
            return newv;
        }
        
        TapSerializer tapSerializer;
        object cloneIfPossible(object value, object context)
        {
            if (value == null) return null;
            var valType = TypeData.GetTypeData(value);
            var td = valType.AsTypeData();
            if (td.IsValueType)
                return value;
            
            if (StringConvertProvider.TryGetString(value, out string result))
            {
                if (StringConvertProvider.TryFromString(result, valType, context, out object result2))
                    return result2;
            }
            
            if(tapSerializer == null) tapSerializer = new TapSerializer();
            try
            {
                return tapSerializer.DeserializeFromString(tapSerializer.SerializeToString(value), valType) ?? value;
            }
            catch
            {
                return value;
            }
        }

        public IEnumerable<(object Source, IMemberData Member)> ParameterizedMembers { get; }
    }
    
    class SweepRowTypeData : ITypeData
    {
        public IEnumerable<object> Attributes => BaseType.Attributes;
        
        // Sweep row type data cannot be deserialized in a normal sense anyway. Needs sweep step reference
        public string Name => BaseType.Name; 
        public ITypeData BaseType { get; } = TypeData.FromType(typeof(SweepRow));
        public IEnumerable<IMemberData> GetMembers() => BaseType.GetMembers().Concat(GetSweepMembers());

        IEnumerable<IMemberData> GetSweepMembers()
        {
            var selected = SweepParameterLoop.SelectedParameters;
            var loopMembers = TypeData.GetTypeData(SweepParameterLoop).GetMembers()
                .Where(x => selected.Contains(x))
                .OfType<IParameterMemberData>();
            return loopMembers.Select(x => new SweepRowMemberData(this, x));
        } 

        public IMemberData GetMember(string name)
        {
            return BaseType.GetMember(name) ?? GetSweepMembers().FirstOrDefault(x => x.Name == name);
        }

        public SweepParameterStep SweepParameterLoop;

        public SweepRowTypeData(SweepParameterStep sweepParameterLoop)
        {
            this.SweepParameterLoop = sweepParameterLoop;
        }
        
        public object CreateInstance(object[] arguments)
        {
            throw new Exception("Cannot create instance");
        }

        public bool CanCreateInstance => false;

        public override bool Equals(object obj)
        {
            if (obj is SweepRowTypeData otherSweepRow && otherSweepRow.SweepParameterLoop == SweepParameterLoop)
                return true;
            return false;
        }

        public override int GetHashCode()
        {
            return SweepParameterLoop.GetHashCode() * 37012721 + 1649210;
        }
    };
}