using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Linq;

namespace OpenTap.Package
{
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
    internal class DependsOnAttribute : Attribute
    {
        public Type Dependent { get; set; }

        public DependsOnAttribute(Type dependent)
        {
            if (TypeData.FromType(dependent).DescendsTo(typeof(IElementExpander)) == false)
                throw new Exception($"Type '{dependent.Name}' is not an {nameof(IElementExpander)}.");
            Dependent = dependent;
        }
    }

    internal interface IElementExpander
    {
        /// <summary>
        /// Expand all attributes and text on the input element
        /// </summary>
        /// <param name="element"></param>
        /// <returns></returns>
        void Expand(XElement element);
    }

    [DependsOn(typeof(VariableExpander))]
    [DependsOn(typeof(EnvironmentVariableExpander))]
    [DependsOn(typeof(GitVersionExpander))]
    [DependsOn(typeof(DefaultVariableExpander))]
    internal class ConditionExpander : IElementExpander
    {
        private static TraceSource log = Log.CreateSource("Condition Evaluator");
        /// <summary>
        /// Evaluate any 'Condition' attribute and remove the element if it is not satisfied
        /// Otherwise remove the condition
        /// </summary>
        /// <param name="element"></param>
        public void Expand(XElement element)
        {
            foreach (var condition in element.Attributes("Condition").ToArray())
            {
                if (EvaluateCondition(condition) && condition.Parent != null)
                    condition.Remove();
                else
                {
                    if (element.Parent != null)
                        element.Remove();
                    break;
                }
            }
        }

        internal string GetExpansion(string condition)
        {
            string normalize(string str)
            {
                // Trim leading and trailing space
                str = str.Trim();

                if (str == string.Empty) return string.Empty;

                // Remove one level of quotes if present
                if ((str[0] == '\'' || str[0] == '"') && str.First() == str.Last())
                    str = str.Substring(1, str.Length - 2);
                return str;
            }

            // Check if the condition is a literal
            var norm = normalize(condition);

            if (string.IsNullOrWhiteSpace(norm)) return string.Empty;

            if (norm.IndexOf("==", StringComparison.Ordinal) < 0 &&
                norm.IndexOf("!=", StringComparison.Ordinal) < 0)
                return norm;

            condition = condition.Trim();
            var parts = condition.Split(new string[] { "==", "!=" }, StringSplitOptions.None)
                .Select(p => p.Trim())
                .ToArray();

            var lhs = normalize(parts[0]);
            var rhs = normalize(parts[1]);

            var isEquals = condition.IndexOf("==", StringComparison.Ordinal) >= 0;
            var areEqual = lhs.Equals(rhs, StringComparison.Ordinal);
            return isEquals == areEqual ? "true" : string.Empty;
        }

        bool EvaluateCondition(XAttribute attr)
        {
            var condition = attr.Value;
            var result = GetExpansion(condition).Any();
            if (attr.Parent is IXmlLineInfo li && li.HasLineInfo())
            {
                log.Debug($@"XML Line {li.LineNumber}: Evaluated Condition=""{condition}"" to ""{result}""");
            }
            return result;
        }
    }

    [DependsOn(typeof(GitVersionExpander))]
    internal class VariableExpander : IElementExpander
    {
        private static TraceSource log = Log.CreateSource(nameof(VariableExpander));
        public VariableExpander(ElementExpander s)
        {
            Stack = s;
        }

        internal void InitVariables(IEnumerable<XElement> variablesGroup)
        {
            foreach (var propertyGroup in variablesGroup)
            {
                var desc = propertyGroup.Descendants().ToArray();
                foreach (var variable in desc)
                {
                    var k = variable.Name.LocalName;
                    // Overriding an existing key is fine here
                    // It could be intentional. E.g.
                    // <PATH>$(PATH):abc</PATH>
                    // followed by
                    // <PATH>$(PATH):def</PATH>
                    Stack.ExpandElement(variable);
                    // The variable may have been removed from the document if its condition was 'false'
                    // In this case, do not add its value as a property.
                    if (variable.Parent != null)
                        Variables[k] = variable.Value;
                }
            }

            log.Debug($"Initialized variable expander:");
            foreach (var kvp in Variables)
            {
                log.Debug($"{kvp.Key} = '{kvp.Value}'");
            }
        }

        private Dictionary<string, string> Variables { get; } = new Dictionary<string, string>();
        public ElementExpander Stack { get; set; }
        public void Expand(XElement element)
        {
            foreach (var key in Variables.Keys)
            {
                ExpansionHelper.ReplaceToken(element, key, Variables[key].ToString());
            }
        }
    }

    [DependsOn(typeof(GitVersionExpander))]
    [DependsOn(typeof(VariableExpander))]
    internal class EnvironmentVariableExpander : IElementExpander
    {
        public EnvironmentVariableExpander()
        {
            Variables = Environment.GetEnvironmentVariables();
            Keys = Variables.Keys.OfType<string>().ToArray();
        }

        private IDictionary Variables { get; }
        private string[] Keys { get; }

        public void Expand(XElement element)
        {
            foreach (var key in Keys)
            {
                ExpansionHelper.ReplaceToken(element, key, Variables[key].ToString());
            }
        }
    }

    [DependsOn(typeof(GitVersionExpander))]
    [DependsOn(typeof(VariableExpander))]
    [DependsOn(typeof(EnvironmentVariableExpander))]
    internal class DefaultVariableExpander : IElementExpander
    {
        private static Regex VariableRegex = new Regex("\\$!?\\(.*?\\)");
        public HashSet<string> UndefinedVariables = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        /// <summary>
        /// Replace all variables with an empty string. E.g. '$(whatever) -> '')'
        /// </summary>
        /// <param name="element"></param>
        public void Expand(XElement element)
        {
            var textNodes = element.Nodes().OfType<XText>().ToArray();

            foreach (var textNode in textNodes)
            {
                foreach (Match match in VariableRegex.Matches(textNode.Value))
                {
                    if (match.Value.StartsWith("$!("))
                        UndefinedVariables.Add(match.Value.Substring(3, match.Value.Length - 4));
                    textNode.Value = textNode.Value.Replace(match.Value, "");
                }
            }

            var attributeNodes = element.Attributes().ToArray();
            foreach (var attribute in attributeNodes)
            {
                foreach (Match match in VariableRegex.Matches(attribute.Value))
                {
                    if (match.Value.StartsWith("$!("))
                        UndefinedVariables.Add(match.Value.Substring(3, match.Value.Length - 4));
                    attribute.Value = attribute.Value.Replace(match.Value, "");
                }
            } 
        }
    }

    internal class GitVersionExpander : IElementExpander
    {
        public GitVersionExpander(string projectDir)
        {
            ProjectDir = projectDir;
        }

        private string ProjectDir { get; }

        private string longVersion = null;

        private string version = null;

        private static TraceSource log = Log.CreateSource(nameof(GitVersionExpander));

        public void Expand(XElement element)
        {
            ReplaceVersion("GitVersion", 5, ref version);
            ReplaceVersion("GitLongVersion", 4, ref longVersion);

            void ReplaceVersion(string versionName, int fieldCount, ref string cachedVersion)
            {
                if (!element.ToString().Contains("$(" + versionName + ")"))
                    return;

                if (cachedVersion == null && string.IsNullOrWhiteSpace(ProjectDir) == false)
                {
                    try
                    {
                        var calc = new GitVersionCalulator(ProjectDir);
                        cachedVersion = calc.GetVersion().ToString(fieldCount);
                        log.Info("Package {1} is {0}", cachedVersion, versionName);
                    }
                    catch (Exception ex)
                    {
                        log.ErrorOnce(cachedVersion, "Failed to calculate {0}.", versionName);
                        log.Debug(ex);
                    }
                }

                // If 'GitVersion' could not be resolved, don't replace it
                if (cachedVersion != null)
                    ExpansionHelper.ReplaceToken(element, versionName, cachedVersion);
            }
        }
    }
}