using System;

using System.Linq;

using System.Text.RegularExpressions;

using System.Text;

using System.Collections.Generic;

public class Program

{

    public static void Main()

    {

        var appTypes = new List<string>() { "QPP/QPX", "Android-App", "Firmware" };

        if (Compatibility.TryParse(">3", appTypes, 4, out Compatibility compat, out string error))

        {

            compat.Incompatible = true;

            Console.WriteLine("{0}, incompatible = {1}", compat, compat.Incompatible);

            //Console.WriteLine(compat.ToDescription(false));

            Console.WriteLine(compat.IsCompatible("3.3.3"));

        }

        else

        {

            Console.WriteLine(error);   

        }

    }

    public static readonly List<int> FirmwareAssets = new List<int> { 4, 5, 8 };

    public class Condition

    {

        /// <summary>

        /// Extracts operator and possibly valid version

        /// </summary>

        private static readonly Regex _conditionPattern = new Regex(@"^(EQ_|LOW_|LOWEQ_|HIG_|HIGEQ_|LIK_|>=|>|<=|<)?(\d+(\.(\d+|\*))+)$");

​

        /// <summary>

        /// UI operators and db operators

        /// </summary>

        private static readonly IDictionary<string, string> _dbOperators = new Dictionary<string, string>

        {

            { "<", "LOW_" },

            { "<=", "LOWEQ_" },

            { "", "EQ_" },

            { ">", "HIG_" },

            { ">=", "HIGEQ_" },

            { "*", "LIK_" }

        };

​

        public string Asset { get; set; }

​

        /// <summary>

        /// Either the file or firmware

        /// </summary>

        public string Target { get; set; }

​

        public string Operator { get; set; }

​

        public Version Version { get; set; }

​

        public static bool TryParse(string condition, int asset, IEnumerable<string> appTypes, out Condition result, out string error)

        {

            result = null;

            error = null;

​

            // Firmware-type assets can only define self-(in)compatabilities

            bool selfCompat = FirmwareAssets.Contains(asset);

​

            string[] parts = condition.Trim('"').Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);

​

            if (!parts.Any())

            {

                error = $"Invalid condition \"{condition}\"";

                return false;

            }

            // validate parts of condition based on type

            if (selfCompat)  // <condition> (firmware file condition)

            {

                if (parts.Length != 1)

                    error = $"Condition \"{condition}\" must only contain the firmware version condition";

            }

            else if (parts.First().Contains("Firmware"))  // Firmware <model>:<condition> (condition targeting firmware)

            {

                // Apps eligible devices QT850 Firmware: < 2.36 or QT850c Firmware: <= 3.35

                if (parts.Length != 2)

                    error = $"Condition \"{condition}\" must only contain the terminal model and firmware version condition";

            }

            else  // <type>:<file>:<condition>

            {

                // Other App Types --> QPP/QPX: NAB Generic : 2.59 or Android-App: Camera : 1.56

                if (parts.Length != 3)

                    error = $"Condition \"{condition}\" must contain asset type, file name, and file version";

​

                // Check the condition starts with the permitted AppTypes

                else if (appTypes == null || !appTypes.Any(r => parts.First().StartsWith(r)))

                    error = $"Condition \"{condition}\" contains an invalid app type";

            }

​

            if (error != null) return false;

​

            string actualCondition = parts.Last().Trim(' ');

            Match conditionMatch = _conditionPattern.Match(actualCondition);

​

            if (!conditionMatch.Success)

            {

                error = $"Unexpected condition \"{condition}\"";

                return false;

            }

​

            string rawOp = conditionMatch.Groups[3].Value == ".*" ? "*" : conditionMatch.Groups[1].Value;

            string rawVer = conditionMatch.Groups[2].Value;

​

            string @operator = GetOperatorSymbol(rawOp, true);  // store operator as viewable

​

            if (@operator == null)

            {

                error = $"Invalid condition operator \"{rawOp}\"";

                return false;

            }

​

            @operator = GetOperatorSymbol(@operator, true);  // internally store viewable symbols

​

            if (!Version.TryParse(@operator == "*" ? rawVer.Replace(".*", "") : rawVer, out Version version))

            {

               error = $"Invalid condition version \"{rawVer}\"";

               return false;

            }

​

            result = new Condition

            {

                Asset = parts.Length == 3 ? parts.First() : null,

                Target = parts.Length > 1 ? parts.Skip(parts.Length - 2).First() : null,

                Operator = @operator,

                Version = version

            };

​

            return error == null;

        }

​

        public string ToDescription(bool viewable = true)

        {

            var sb = new StringBuilder();

​

            bool complex = Asset != null || Target != null;

​

            if (complex) sb.Append('"');

​

            if (Asset != null) sb.Append(Asset).Append(':');

            if (Target != null) sb.Append(Target).Append(':');

​

            string @operator = GetOperatorSymbol(Operator, viewable);

​

            if (@operator == "*")

            {

                if (viewable)

                    sb.Append(Version).Append(".*");

                else

                    sb.Append(@operator).Append(Version);

            }

            else

            {

                sb.Append(@operator).Append(Version);

            }

​

            if (complex) sb.Append('"');

​

            return sb.ToString();

        }

​

        public override string ToString()

        {

            return ToDescription();

        }

​

        private static string GetOperatorSymbol(string @operator, bool viewable)

        {

            KeyValuePair<string, string> operatorPair = _dbOperators.FirstOrDefault(p => p.Value == @operator || p.Key == @operator);

            return viewable ? operatorPair.Key : operatorPair.Value;

        }

​

        public bool TestCondition(Version fileVersion, string target)

        {

            if (target != Target)

                return false;  // condition not applicable to file/firmware model

​

            switch (Operator)

            {

                case "":

                    return fileVersion == Version;

​

                case ">":

                    return fileVersion > Version;

​

                case ">=":

                    return fileVersion >= Version;

​

                case "<":

                    return fileVersion < Version;

​

                case "<=":

                    return fileVersion <= Version;

​

                case "*":

                    return fileVersion.Major == Version.Major &&

                            (Version.Minor == -1 || fileVersion.Minor == Version.Minor) &&

                            (Version.Build == -1 || fileVersion.Build == Version.Build) &&

                            (Version.Revision == -1 || fileVersion.Revision == Version.Revision);

​

                default:

                    return false;  // unrecognised operator

            }

        }

    }

​

    public class Compatibility

    {

        private IEnumerable<Condition> _conditions;

​

        public bool Incompatible { get; set; } = true;

​

        /// <summary>

        /// Compatability value representing no file (in)compatability

        /// </summary>

        public const string NaCondition = "NA";

​

        public Compatibility(IEnumerable<Condition> conditions)

        {

            _conditions = conditions;

        }

​

        public IEnumerable<Condition> Conditions

        {

            get

            {

                return _conditions;

            }

        }

​

        public static bool TryParse(string compatibility, IEnumerable<string> appTypes, int asset, out Compatibility result, out string error)

        {

            result = null;

            error = null;

            var errors = new List<string>();

​

            var parsedConditions = new List<Condition>();

​

            if (string.IsNullOrWhiteSpace(compatibility) || compatibility.Trim() == NaCondition)

            {

                result = new Compatibility(parsedConditions);

                return true;

            }

​

            string[] conditions = compatibility.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

​

            foreach (string c in conditions)

            {

                if (string.IsNullOrWhiteSpace(c)) continue;

                if (Condition.TryParse(c.Trim(), asset, appTypes, out Condition condition, out string conditionError))

                {

                    parsedConditions.Add(condition);

                }

                else

                {

                    errors.Add(conditionError);

                }

            }

​

            if (errors.Any())

            {

                error = string.Join(". ", errors);

                // TODO: add extra errors so they are caught: e.g., " :  :"

            }

            else

            {

                result = new Compatibility(parsedConditions);

            }

​

            return result != null;

        }

​

        public bool IsCompatible(Version fileVersion, string target = null)

        {

            if (_conditions.Any(c => c.TestCondition(fileVersion, target)))

            {

                return !Incompatible;

            }

​

            return Incompatible;

        }

​

        /// <summary>

        /// 

        /// </summary>

        /// <param name="fileVersion"></param>

        /// <param name="target">The file name or firmware description</param>

        /// <returns></returns>

        public bool IsCompatible(string fileVersion, string target = null)

        {

            return !Version.TryParse(fileVersion, out Version parsedVersion) ||   // can't compare bad file version

                    IsCompatible(parsedVersion, target);

        }

​

        /// <summary>

        /// Get viewable representation of compatibility

        /// </summary>

        /// <returns></returns>

        public override string ToString()

        {

            return ToDescription();

        }

​

        public string ToDescription(bool viewable = true)

        {

            var sb = new StringBuilder();

​

            if (!_conditions.Any())

                return viewable ? string.Empty : NaCondition;

​

            return string.Join(",", _conditions.Select(c => c.ToDescription(viewable)));

        }

    }

}