public static RulesModel ReadRuleFile(string path)
        {
            RulesModel rules = new RulesModel();

            rules.Rules = new List <Rule>();

            if (File.Exists(path))
            {
                using (StreamReader sr = new StreamReader(path))
                {
                    string line = string.Empty;
                    while ((line = sr.ReadLine()) != null)
                    {
                        Rule rule = new Rule();
                        if (line == string.Empty || line[0] == '!')
                        {
                            continue;
                        }
                        else if (int.TryParse(line[0].ToString(), out int specificity))
                        {
                            var values = line.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                            values.ToList().ForEach(t => t.Trim());

                            if (values.Length == 3 && int.TryParse(values[1], out int strength) &&
                                int.TryParse(values[2], out int matchingCase))
                            {
                                rule.Strength      = strength;
                                rule.Specificity   = specificity;
                                rule.MatchingCases = matchingCase;

                                rule.Attributes = new OrderedDictionary();

                                var rulLine = sr.ReadLine();
                                if (!rulLine.Contains("->") && !rulLine.Contains("-->"))
                                {
                                    string tempLine = string.Empty;
                                    while ((tempLine = sr.ReadLine()) != null)
                                    {
                                        rulLine += tempLine;
                                        if (tempLine.Contains("->") || rulLine.Contains("-->"))
                                        {
                                            break;
                                        }
                                    }
                                }

                                var rulData = rulLine.Split(new string[] { "&", "->", "-->" }, StringSplitOptions.RemoveEmptyEntries).ToList();

                                int count = 0;

                                rulData.ForEach(pair =>
                                {
                                    count++;
                                    pair.Trim();

                                    var attrPair = pair.Split(',');

                                    if (count == rulData.Count)
                                    {
                                        rule.Decision = new KeyValuePair <string, string>(ReplaceFirstOccurrence(attrPair[0], "(", "").Trim(), ReplaceLastOccurrence(attrPair[1], ")", "").Trim());
                                    }
                                    else
                                    {
                                        rule.Attributes.Add(ReplaceFirstOccurrence(attrPair[0], "(", "").Trim(), ReplaceLastOccurrence(attrPair[1], ")", "").Trim());
                                    }

                                    rule.CalculatedValue = Decision.CalculateValue(rule);
                                });
                            }
                            else
                            {
                                throw new Exception("Error in Rule File: Incorrect Numbers preceding rule");
                            }
                            rules.Rules.Add(rule);
                        }
                    }
                }
            }
            else
            {
                throw new Exception("Rule File Missing - " + Path.GetFileName(path));
            }
            return(rules);
        }