//            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.ComponentModel;
using System.Linq;
using System.Text.RegularExpressions;
using System.Xml.Serialization;

namespace OpenTap.Plugins.BasicSteps
{
    [Display("Generic SCPI Instrument", Description: "Allows you to configure a VISA based connection to a SCPI instrument.")]
    [Obsolete ("Use OpenTap.ScpiInstrument instead.")]
    [Browsable(false)]
    public class GenericScpiInstrument : ScpiInstrument
    {
        public GenericScpiInstrument()
        {
            Name = "SCPI";
        }
    }

    public enum SCPIAction
    {
        [Display("Command", "SCPI Command.")]
        Command,
        [Display("Query", "SCPI Query.")]
        Query
    }

    public enum SCPIRegexBehavior
    {
        [Display("Groups As Columns", "Each regex group is treated as a separate column.")]
        GroupsAsDimensions,
        [Display("Groups As Rows", "Each regex group is treated as a separate row, with one column.")]
        GroupsAsResults
    }

    public abstract class RegexOutputStep : TestStep
    {
        [Browsable(false)]
        [XmlIgnore]
        public abstract bool GeneratesOutput { get; }

        private static bool IsValidRegex(string pattern)
        {
            if (string.IsNullOrEmpty(pattern)) return false;
            try
            {
                Regex.Match("", pattern);
            }
            catch (ArgumentException)
            {
                return false;
            }

            return true;
        }

        [EnabledIf(nameof(GeneratesOutput), true, HideIfDisabled = true)]
        [Display("Regular Expression", Group: "Set Verdict", Order: 1.1, Collapsed: true, Description: "The regular expression to apply to the output.")]
        [HelpLink("EditorHelp.chm::/CreatingATestPlan/Working with Test Steps/Using Regex in Output Parameters.html")]
        public Enabled<string> RegularExpressionPattern { get; set; }

        
        [EnabledIf(nameof(GeneratesOutput), true, HideIfDisabled = true)]
        [EnabledIf("RegularExpressionPattern", true, HideIfDisabled = true)]
        [Display("Verdict on Match", Group: "Set Verdict", Order: 1.2, Collapsed: true, Description: "The verdict of the step when the regex did match the result.")]
        public Verdict VerdictOnMatch { get; set; }

        [EnabledIf(nameof(GeneratesOutput), true, HideIfDisabled = true)]
        [EnabledIf("RegularExpressionPattern", true, HideIfDisabled = true)]
        [Display("Verdict on No Match", Group: "Set Verdict", Order: 1.3, Collapsed: true, Description: "The verdict of the step when the regex did not match the result.")]
        public Verdict VerdictOnNoMatch { get; set; }

        [EnabledIf(nameof(GeneratesOutput), true, HideIfDisabled = true)]
        [Display("Regular Expression", Group: "Results", Order: 1.5, Collapsed: true, Description: "The regular expression to apply to the output.")]
        [HelpLink("EditorHelp.chm::/CreatingATestPlan/Working with Test Steps/Using Regex in Output Parameters.html")]
        public Enabled<string> ResultRegularExpressionPattern { get; set; }

        [EnabledIf(nameof(GeneratesOutput), true, HideIfDisabled = true)]
        [EnabledIf(nameof(ResultRegularExpressionPattern), true, HideIfDisabled = true)]
        [Display("Result Name", Group: "Results", Order: 1.51, Collapsed: true, Description: "The name of the result.")]
        public string ResultName { get; set; }

        [EnabledIf(nameof(GeneratesOutput), true, HideIfDisabled = true)]
        [EnabledIf(nameof(ResultRegularExpressionPattern), true, HideIfDisabled = true)]
        [Display("Regex Behavior", Group: "Results", Order: 1.51, Collapsed: true, Description: "How the step should publish the matched values of the regular expression as a result table.")]
        public SCPIRegexBehavior Behavior { get; set; }

        [EnabledIf(nameof(GeneratesOutput), true, HideIfDisabled = true)]
        [EnabledIf(nameof(ResultRegularExpressionPattern), true, HideIfDisabled = true)]
        [Display("Column Names", Group: "Results", Order: 1.51, Collapsed: true, Description: "The name of the columns of the resulting groups. The titles must be separated by commas.")]
        public string DimensionTitles { get; set; }
        
        public RegexOutputStep()
        {
            RegularExpressionPattern = new Enabled<string>() { IsEnabled = false, Value = "(.*)" };
            VerdictOnMatch = Verdict.Pass;
            VerdictOnNoMatch = Verdict.Fail;

            ResultRegularExpressionPattern = new Enabled<string>() { IsEnabled = false, Value = "(.*)" };
            Behavior = SCPIRegexBehavior.GroupsAsDimensions;
            ResultName = "Regex Result";
            DimensionTitles = "";
            
            Rules.Add(new ValidationRule(() => ResultRegularExpressionPattern.IsEnabled == false || IsValidRegex(ResultRegularExpressionPattern.Value), "Invalid regular expression.", nameof(ResultRegularExpressionPattern)));
            Rules.Add(new ValidationRule(() => RegularExpressionPattern.IsEnabled == false || IsValidRegex(RegularExpressionPattern.Value), "Invalid regular expression.", "RegularExpressionPattern"));
            
        }

        protected void ProcessOutput(string output)
        {
            if (RegularExpressionPattern.IsEnabled)
            {
                var Matches = Regex.Matches(output, RegularExpressionPattern.Value);

                if (Matches.Count > 0)
                    UpgradeVerdict(VerdictOnMatch);
                else
                    UpgradeVerdict(VerdictOnNoMatch);
            }

            if (ResultRegularExpressionPattern.IsEnabled)
            {
                var Matches = Regex.Matches(output, ResultRegularExpressionPattern.Value);

                foreach (Match Match in Matches)
                {
                    if ((Match.Length <= 0) || (!Match.Success))
                        continue;

                    switch (Behavior)
                    {
                        case SCPIRegexBehavior.GroupsAsDimensions:
                            {
                                var Name = ResultName;
                                var titles = DimensionTitles.Split(',').ToList();
                                var results = Match.Groups.OfType<Capture>().Skip(1).Select(x => x.Value).ToList();

                                if (titles.Count != results.Count)
                                {
                                    Log.Error("Number of Column Names ({0}) does not match number of results ({1}).", titles.Count, results.Count);
                                    UpgradeVerdict(Verdict.Error);
                                    return;
                                }

                                Results.Publish(Name, titles, results.ToArray());
                                break;
                            }
                        case SCPIRegexBehavior.GroupsAsResults:
                            {
                                var Name = ResultName;
                                var titles = DimensionTitles.Split(',').ToList();

                                if (titles.Count != 1)
                                {
                                    Log.Error("Number of Column Names ({0}) does not match number of results (1).", titles.Count);
                                    UpgradeVerdict(Verdict.Error);
                                    return;
                                }

                                for (int i = 1; i < Match.Groups.Count; i++)
                                {
                                    Results.Publish(Name, titles, Match.Groups[i].Value);
                                }
                                break;
                            }
                    }
                }
            }
        }
    }

    [Browsable(false)]
    [Display("SCPI", Group: "Basic Steps", Description: "Sends a SCPI (Standard Commands for Programmable Instruments) command or query to a SCPI instrument. For queries, it processes the result with regular expressions.")]
    public class SCPIRegexStep : RegexOutputStep
    {
        [Browsable(false)]
        [XmlIgnore]
        public override bool GeneratesOutput => Action == SCPIAction.Query; 

        [Display("Instrument", Order: 0.0, Description: "The instrument that the query is sent to.")]
        public ScpiInstrument Instrument { get; set; }

        [Display("Action", Order: 0.1, Description: "The type of SCPI action to perform.")]
        public SCPIAction Action { get; set; }
        
        [Display("Command", Order: 0.2, Description: "The command or query to send to the instrument.")]
        public string Query { get; set; }

        [EnabledIf(nameof(Action), SCPIAction.Query)]
        [Display("Add to Log", Order: 0.3, Description: "If enabled the result of the query is added to the log.")]
        public bool AddToLog { get; set; }

        [EnabledIf(nameof(AddToLog), true, HideIfDisabled = true)]
        [EnabledIf(nameof(Action), SCPIAction.Query, HideIfDisabled = true)]
        [Display("Log Header", Order: 0.4, Description: "This string is added to the front of the result of the query.")]
        public string LogHeader { get; set; }
        
        [Browsable(true)]
        [Display("Response", "The text response from the instrument. This is only valid when the action type is query.", Group: "Results", Order: 1.55 )]
        [EnabledIf(nameof(Action), SCPIAction.Query, HideIfDisabled = true)]
        public string Response { get; private set; }
        
        public SCPIRegexStep()
        {
            Action = SCPIAction.Query;
            AddToLog = true;
            Rules.Add(() => !string.IsNullOrEmpty(Query), "Command cannot be empty.", nameof(Query));
            Rules.Add(() => Instrument != null, "An instrument must be selected.", nameof(Instrument));
            Rules.Add(() =>
                !(Query?.EndsWith("?") == true && Action == SCPIAction.Command), "A command cannot end with '?'", nameof(Query));
            // Queries may contain arguments e.g 'SYST:CHAN:MOD? (@1,2)'
            Rules.Add(() => 
                !(Query?.Contains("?") == false && Action == SCPIAction.Query), "A query must contain '?'", nameof(Query));
            Query = "*IDN?";
        }
        
        public override void Run()
        {
            Response = "";
            if (Action == SCPIAction.Command)
            {
                Instrument.ScpiCommand(Query);
            }
            else
            {
                string Result = Instrument.ScpiQuery(Query);
                Response = Result;

                if (AddToLog)
                    Log.Info(LogHeader + Result);

                ProcessOutput(Result);
            }
        }
    }
}