using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using HeuristicLab.Optimization;

namespace HeuristicLab.Problems.DataAnalysis {
  public class IntervalConstraintsParser {
    public IntervalConstraintsParser() {}
    private List<IntervalConstraint> intervalConstraints = new List<IntervalConstraint>();
    public List<IntervalConstraint> Parse(string input) {
      var options = RegexOptions.Multiline | RegexOptions.IgnoreCase;
      var matches = Regex.Matches(input, @"^(.*)\bin\b\s*([\[\]])(.*[^\s])(\s*\.\.\s*)([^\s].*)([\[\]])\r?\s*$", options);

      for (var i = 0; i < matches.Count; ++i) {
        if (matches[i].Groups.Count == 7) { 
          var intervalConstraint = new IntervalConstraint();
          //pattern 1 = defintion
          var definition = Regex.Replace(matches[i].Groups[1].Value, @"\s *", "");
          if (Regex.IsMatch(definition, @"\/")) {
            var splitted = Regex.Split(definition.Replace(" ", string.Empty), @"\/");
            var match = Regex.Match(splitted[0], @"([d∂])([0-9]|[²³])?(.*[^\s*])");
            if (match.Success) {
              intervalConstraint.NumberOfDerivation = match.Groups[2].Success ? ParseDerivationCount(match.Groups[2].Value) : 1;
              intervalConstraint.Definition = match.Groups[3].Value;
              intervalConstraint.IsDerivation = true;
              var formulation = Regex.Match(splitted[1], @"([d∂])(.*[^²³])([²³])?");
              if (formulation.Success) {
                intervalConstraint.Variable = formulation.Groups[2].Success ? formulation.Groups[2].Value : "";
              }
            } else {
              throw new ArgumentException($"An error occured in the derivation part: {splitted[0]}");
            }
          } else {
            intervalConstraint.Definition = Regex.Match(definition, @".*[^.\s]*").Value;
            intervalConstraint.IsDerivation = false;
          }
          intervalConstraint.Derivaiton = matches[i].Groups[0].Value;
          intervalConstraint.InclusiveLowerBound = (matches[i].Groups[2].Value == "[");
          intervalConstraint.InclusiveUpperBound = (matches[i].Groups[6].Value == "]");
          intervalConstraint.Interval = new Interval(ParseIntervalBounds(matches[i].Groups[3].Value.Replace(" ", string.Empty)), 
            ParseIntervalBounds(matches[i].Groups[5].Value.Replace(" ", string.Empty)));

          intervalConstraints.Add(intervalConstraint);
        } else {
          throw new ArgumentException($"The given constraint: {matches[i].Value} is not valid.");
        }
      }

      return intervalConstraints;
    }

    private static double ParseIntervalBounds(string input) {
      input = input.ToLower();
      switch (input) {
        case "+inf.":
        case "inf.":
          return double.PositiveInfinity;
        case "-inf.":
          return double.NegativeInfinity;
        default: {
          if (double.TryParse(input, NumberStyles.Any, CultureInfo.InvariantCulture, out var value)) {
            return value;
          } else {
            throw new ArgumentException("The given Interval in the constraint is not valid.");
          }
        }
      }
    }

    private static int ParseDerivationCount(string input) {
      switch (input) {
        case "²":
          return 2;
        case "³":
          return 3;
        default:
          int.TryParse(input, out var value);
          return value;
      }
    }
  }
}