using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
using System.Globalization;
using System.Xml;

namespace HeuristicLab.Services.Optimization.ControllerService.Model {
  [DataContract]
  public enum ParameterType {
    [EnumMember]
    Decimal,
    [EnumMember]
    Integer,
    [EnumMember]
    Boolean,
    [EnumMember]
    Type,
    [EnumMember]
    DecimalMatrix,
    [EnumMember]
    DecimalVector,
    [EnumMember]
    Percent
  }

  [DataContract]
  public abstract class Value {
    [DataMember]
    public string Name { get; set; }

    public abstract bool TrySetFromString(string input);
  }


  [DataContract]
  public class DecimalMatrix : Value {
    [DataMember]
    public double[][] Value { get; set; }

    public override bool TrySetFromString(string input) {
      var splitted = input.Split(':');
      int i, j;
      if (splitted.Length != 3)
        return false;

      if (!int.TryParse(splitted[0], out i))
        return false;

      if (!int.TryParse(splitted[1], out j))
        return false;

      double value;
      if (!double.TryParse(splitted[2], out value))
        return false;
      // very, very buggy
      if (i >= Value.Length || j >= Value[0].Length ) {
        double[][] valueArr = new double[i >= Value.GetLength(0) ? i : Value.GetLength(0)][];        
        for (int k = 0; k < Value.Length; k++) {
          valueArr[k] = new double[j >= Value.GetLength(1) ? j : Value.GetLength(1)];
          for (int l = 0; l < Value[k].Length; l++) {
            valueArr[k][l] = Value[k][l];
          }
        }
        Value = valueArr;
      }

      Value[i][j] = value;
      return true;
    }
  }

  [DataContract]
  public class DecimalVector : Value {
    [DataMember]
    public double[] Value { get; set; }

    public override bool TrySetFromString(string input) {
      var splitted = input.Split(':');
      int index;
      if (splitted.Length != 2)
        return false;

      if (!int.TryParse(splitted[0], out index))
        return false;

      double value;
      if (!double.TryParse(splitted[1], out value))
        return false;

      if (index >= Value.Length) {
        double[] valueArr = new double[index + 1];
        Array.Copy(Value, valueArr, Value.Length);
        Value = valueArr;
      }

      Value[index] = value;
      return true;
    }
  }

  [DataContract]
  public class TypeValue : Value {
    [DataMember]
    public string Value { get; set; }

    [DataMember]
    public string[] Options { get; set; }

    public override bool TrySetFromString(string input) {
      if (Options.Contains(input)) {
        Value = input;
        return true;
      }
      return false;
    }
  }

  [DataContract]
  public class DecimalValue : Value {
    [DataMember]
    public double Value { get; set; }

    public override bool TrySetFromString(string input) {
      double result;
      if (double.TryParse(input, out result)) {
        Value = result;
        return true;
      }
      return false;
    }
  }

  [DataContract]
  public class BoolValue : Value {
    [DataMember]
    public bool Value { get; set; }

    public override bool TrySetFromString(string input) {
      bool result;
      if (input.Contains(","))
        input = input.Split(',')[0].Trim();
      if (bool.TryParse(input, out result)) {
        Value = result;
        return true;
      }
      return false;
    }
  }

  [DataContract]
  [KnownType(typeof(BoolValue))]
  [KnownType(typeof(DecimalValue))]
  [KnownType(typeof(TypeValue))]
  [KnownType(typeof(DecimalVector))]
  [KnownType(typeof(DecimalMatrix))]
  public class Parameter {        
    // some kind of value type
    [DataMember]
    public ParameterType Type { get; set; }
    
    [DataMember]
    public Value Value { get; set; }    
    /*
    //[DataMember]
    public object[] Choices { get; set; }*/
  }

  [DataContract]
  public class InputParameters {
    private IList<Parameter> items = new List<Parameter>();

    [DataMember]
    public IList<Parameter> Items {
      get { return items; }
      set { items = value; }
    }
  }

  [DataContract]
  public class AlgorithmParameters {
    private IList<Parameter> items = new List<Parameter>();

    [DataMember]
    public IList<Parameter> Items {
      get { return items; }
      set { items = value; }
    }
  }

  [DataContract]
  public class OptimizationScenario {
    [DataMember]
    public string Name { get; set; }

    private InputParameters inputParams = new InputParameters();

    [DataMember]
    public InputParameters InputParameters {
      get { return inputParams; }
      set { inputParams = value; }
    }


    private AlgorithmParameters algorithmParameters = new AlgorithmParameters();

    [DataMember]
    public AlgorithmParameters AlgorithmParameters {
      get { return algorithmParameters; }
      set { algorithmParameters = value; }
    }

  }
}