using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;

namespace OpenTap.Plugins.BasicSteps
{
    [Browsable(false)]
    [AllowAnyChild]
    [Display("Sweep Parameter", "Table based loop that sweeps the value of its parameters based on a set of values.", "Flow Control")]
    public class SweepParameterStep : SweepParameterStepBase
    {
        public bool SweepValuesEnabled => SelectedParameters.Count > 0;

        
        [DeserializeOrder(1)] // this should be deserialized as the last thing.
        [Display("Sweep Values", "A table of values to be swept for the selected parameters.", "Sweep")]
        [HideOnMultiSelect] // todo: In the future support multi-selecting this.
        [EnabledIf(nameof(SweepValuesEnabled), true)]
        [Unsweepable, Unmergable]
        [ElementFactory(nameof(NewElement))]
        [Factory(nameof(NewSweepRowCollection))]
        public SweepRowCollection SweepValues { get; set; } 

        /// <summary>
        /// This property declares to the Resource Manager which resources are declared by this test step. 
        /// </summary>
        [AnnotationIgnore]
        [EditorBrowsable(EditorBrowsableState.Never)]
        [Browsable(false)]
        public IEnumerable<IResource> Resources
        {
            get
            {
                foreach (var row in SweepValues)
                {
                    if (row.Enabled == false) continue;
                    foreach (var value in row.Values.Values)
                    {
                        if (value is IResource res)
                            yield return res;
                    }
                }
            }
        }
            
        public SweepParameterStep()
        {
            SweepValues = new SweepRowCollection(this);
            Name = "Sweep {Parameters}";
            Rules.Add(() => string.IsNullOrWhiteSpace(Validate()), Validate, nameof(SweepValues));
        }

        private string lastError = "";

        private string Validate()
        {
            if (!validateSweepMutex.WaitOne(0))
                return lastError;

            try
            {
                if (isRunning)
                    return lastError;

                if (SelectedParameters.Count <= 0)
                {
                    SweepValues = new SweepRowCollection(this);
                }
                {
                    // Remove sweep values not in the selected parameters. This can be needed when the user has removed some.

                    var rows = SweepValues.Select(x => x.Values);
                    var selectedNames = SelectedParameters.Select(x => x.Name);
                    var namesToRemove = rows.SelectMany(x => x.Keys).ToHashSet();
                    namesToRemove.ExceptWith(selectedNames);

                    foreach (var removeName in namesToRemove)
                    foreach (var row in rows)
                        row.Remove(removeName);
                }
                var errors = ValidateSweepValues();
                lastError = errors;
                return errors;
            }
            finally
            {
                validateSweepMutex.ReleaseMutex();
            }
        }

        int iteration;
        
        [Output(OutputAvailability.BeforeRun)]
        [Display("Iteration", "Shows the iteration of the sweep that is currently running or about to run.", "Sweep", Order: 3)]
        public string IterationInfo => $"{iteration} of {SweepValues.Count(x => x.Enabled)}";

        bool isRunning => GetParent<TestPlan>()?.IsRunning ?? false;
        
        /// <summary>
        /// Validation requires setting the values of parameterized members.
        /// This mutex will be locked while the test plan is running to prevent validation requests from interfering with test plan runs. 
        /// </summary>
        Mutex validateSweepMutex = new Mutex();

        private string ValidateSweepValues()
        {
            const int maxErrors = 10;
            var sets = SelectedMembers.ToArray();
            if (SweepValues.Count == 0)
                return "No rows selected to sweep.";
            var rowType = SweepValues.Select(TypeData.GetTypeData).FirstOrDefault();
            
            var numErrors = 0;

            string FormatError(string rowDescriptor, string error)
            {
                return $"{rowDescriptor}: {error}";
            }

            List<string> allRowErrors = new List<string>();
            List<(int row, string error)> rowErrors = new List<(int row, string error)>();

            foreach (var set in sets)
            {
                var mem = rowType.GetMember(set.Name);

                // If an error is reported on all rows, only show one validation error
                var allRowsHaveErrors = true;
                var errorTuple = new List<(int row, string error)>();

                foreach (var (index, sweepValue) in SweepValues.WithIndex())
                {
                    if (sweepValue.Enabled == false) continue;

                    var stepsToValidate = new HashSet<ITestStep>();

                    var rowNumber = index + 1;
                    var value = mem.GetValue(sweepValue);

                    try
                    {
                        set.SetValue(this, value);
                        // Don't try to validate a step if SetValue failed
                        set.ParameterizedMembers.ForEach(m =>
                        {
                            if (m.Source is ITestStep step)
                                stepsToValidate.Add(step);
                        });
                    }
                    catch (TargetInvocationException ex)
                    {
                        var reason = ex?.InnerException?.Message;

                        string valueString;
                        if (value == null)
                            valueString = "";
                        else if (false == StringConvertProvider.TryGetString(value, out valueString,
                            CultureInfo.InvariantCulture))
                            valueString = value.ToString();

                        var error = $"Unable to set '{set.GetDisplayAttribute().Name}' to value '{valueString}'";

                        if (reason == null)
                            error += ".";
                        else
                            error += $": {reason}";

                        rowErrors.Add((rowNumber, error));
                        continue;
                    }

                    var hasErrors = false;

                    foreach (ITestStep step in stepsToValidate)
                    {
                        var errors = step.Error;
                        if (string.IsNullOrWhiteSpace(errors) == false)
                        {
                            rowErrors.Add((rowNumber, $"{step.GetFormattedName()} - {errors}"));
                            hasErrors = true;
                            numErrors += 1;
                        }
                    }

                    if (hasErrors == false)
                        allRowsHaveErrors = false;
                }

                if (allRowsHaveErrors && errorTuple.Count > 1 &&
                    errorTuple.Select(t => t.error).Distinct().Count() == 1)
                {
                    var error = errorTuple.First();
                    allRowErrors.Add(error.error);
                    numErrors += 1;
                }

                if (numErrors >= maxErrors)
                    break;
            }
            
            var sb = new StringBuilder();
            foreach (var error in allRowErrors.OrderBy(x => x))
                sb.AppendLine(FormatError($"All rows", error));
            foreach (var error in rowErrors.OrderBy(x => x.error).ToArray().OrderBy(x =>x.row))
                sb.AppendLine(FormatError($"Row {error.row}", error.error));
            return sb.ToString();
        }

        public override void PrePlanRun()
        {
            validateSweepMutex.WaitOne();
            base.PrePlanRun();
            iteration = 0;

            if (SelectedParameters.Count <= 0)
                throw new InvalidOperationException("No parameters selected to sweep");

            if (SweepValues.Count <= 0 || SweepValues.All(x => x.Enabled == false))
                throw new InvalidOperationException("No values selected to sweep");
        }

        public override void PostPlanRun()
        {
            validateSweepMutex.ReleaseMutex();
            base.PostPlanRun();
        }

        public override void Run()
        {
            base.Run();
            iteration = 0;
            var sets = SelectedMembers.ToArray();
            var originalValues = sets.Select(set => set.GetValue(this)).ToArray();

            var rowType = SweepValues.Select(TypeData.GetTypeData).FirstOrDefault();
            for (int i = 0; i < SweepValues.Count; i++)
            {
                SweepRow Value = SweepValues[i];
                if (Value.Enabled == false) continue;
                var AdditionalParams = new ResultParameters();
                
                AdditionalParams.Add("Sweep", "Iteration", iteration + 1, null);


                foreach (var set in sets)
                {
                    var mem = rowType.GetMember(set.Name);
                    var value = mem.GetValue(Value);

                    string valueString;
                    if (value == null)
                        valueString = "";
                    else if (false == StringConvertProvider.TryGetString(value, out valueString,
                        CultureInfo.InvariantCulture))
                        valueString = value.ToString();

                    var disp = mem.GetDisplayAttribute();
                    AdditionalParams.Add(new ResultParameter(disp.Group.FirstOrDefault() ?? "", disp.Name,
                        valueString));

                    try
                    {
                        set.SetValue(this, value);
                    }
                    catch (TargetInvocationException ex)
                    {
                        throw new ArgumentException($"Unable to set '{set.GetDisplayAttribute()}' to '{valueString}' on row {i}: {ex.InnerException.Message}", ex.InnerException);
                    }
                }

                iteration += 1;
                // Notify that values might have changes
                OnPropertyChanged("");

                Log.Info("Running child steps with {0}", Value.GetIterationString());

                var runs = RunChildSteps(AdditionalParams, BreakLoopRequested, throwOnBreak: false).ToArray();
                if (BreakLoopRequested.IsCancellationRequested) break;
                runs.ForEach(r => r.WaitForCompletion());
                if (runs.LastOrDefault()?.BreakConditionsSatisfied() == true)
                    break;
            }

            for (int i = 0; i < sets.Length; i++)
                sets[i].SetValue(this, originalValues[i]);
        }
        
        SweepRow NewElement()
        {
            return new SweepRow(this);
        }
        SweepRowCollection NewSweepRowCollection()
        {
            return new SweepRowCollection(this);
        }
    }
}