source: branches/OaaS/HeuristicLab.Services.Optimization.Controller/Parsers/AlgorithmConverter.cs @ 9227

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Services.Optimization.ControllerService.Model;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;

namespace HeuristicLab.Services.Optimization.ControllerService.Parsers {
  public static class AlgorithmConverter {

    public static Algorithm Convert(string json) {
      var o = JObject.Parse(json);
      return ParseAlgorithm(o);      
    }

    private static Algorithm ParseAlgorithm(JToken obj) {
      var algorithm = new Algorithm();

      foreach (JProperty param in obj["Algorithm Parameters"]) {
        Parameter parameter = CreateParameter(param);
        algorithm.Parameters.Items.Add(parameter);
      }

      var problemParams = obj["Problem Parameters"];
      if (problemParams != null) {
        algorithm.Problem = new Problem();
        foreach (JProperty param in problemParams) {
          Parameter parameter = CreateParameter(param);
          algorithm.Problem.Parameters.Items.Add(parameter);
        }
      }
      return algorithm;
    }

    public static Algorithm ConvertAppend(string json, Algorithm algorithm) {
      var o = JObject.Parse(json);
      foreach (JProperty param in o["Algorithm Parameters"]) {
        Parameter parameter = CreateParameter(param);
        var oldParameter = (from p in algorithm.Parameters.Items where p.Value.Name == parameter.Value.Name select p).FirstOrDefault();
        if (oldParameter != null) {
          oldParameter.Value = parameter.Value;
        }
        else {
          algorithm.Parameters.Items.Add(parameter);
        }
      }

      var problemParams = o["Problem Parameters"];
      if (problemParams != null) {
        algorithm.Problem = new Problem();
        foreach (JProperty param in problemParams) {
          Parameter parameter = CreateParameter(param);          
          var oldParameter = (from p in algorithm.Problem.Parameters.Items where p.Value.Name == parameter.Value.Name select p).FirstOrDefault();
          if (oldParameter != null) {
            oldParameter.Value = parameter.Value;
          }
          else {
            algorithm.Problem.Parameters.Items.Add(parameter);
          }
        }
      }
      return algorithm;
    }

    private static Parameter CreateParameter(JProperty property) {
      JToken token = property.Value;
      switch (token.Type) {
        case JTokenType.Integer:
        case JTokenType.Float:
          return new Parameter() { Type = ParameterType.Decimal, Value = new DecimalValue() { Name = property.Name, Value = (double)property.Value } };
        case JTokenType.Boolean:
          return new Parameter() { Type = ParameterType.Boolean, Value = new BoolValue() { Name = property.Name, Value = (bool)property.Value } };
        case JTokenType.String:
          return new Parameter() { Type = ParameterType.Type, Value = new TypeValue() { Name = property.Name, Value = (string)property.Value } };                  
        case JTokenType.Array:
          var arr = (JArray)token;
          // its a matrix
          if (arr[0].Type == JTokenType.Array) {
            return CreateMatrixParameter(property.Name, arr);
          }
          return CreateVectorParameter(property.Name, arr);
        default:
          throw new Exception("Unhandled datatype: " + property.Type);
      }
    }

    private static Parameter CreateMatrixParameter(string name, JArray arr) {
      double[][] entries = new double[arr.Count][];
      for (int i = 0; i < entries.Length; i++) {
        entries[i] = (from d in arr[i] select (double)d).ToArray<double>();  
      }
      return new Parameter { Type = ParameterType.DecimalMatrix, Value = new DecimalMatrix() { Name = name, Value = entries } };
    }

    private static Parameter CreateVectorParameter(string name, JArray arr) {
      double[] entries = (from d in arr select (double)d).ToArray<double>();
      return new Parameter { Type = ParameterType.DecimalVector, Value = new DecimalVector() { Name = name, Value = entries } };
    }

    public static string ConvertJson(Algorithm algorithm) {
      return JsonConvert.SerializeObject(algorithm);
    }

    
    private class StackEntry {
      public Algorithm Parent { get; set; }
      public JToken Child { get; set; }
    }

    public static Experiment ConvertExperimentSimple(string json) {
      return JsonConvert.DeserializeObject<Experiment>(json, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.Auto });
    }

    public static string ConvertJson(Experiment experiment) {
      return JsonConvert.SerializeObject(experiment, Formatting.None, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto });
    }

    public static Experiment ConvertExperiment(string json) {
      var experiment = new Experiment();
      var jsonExperiment = JObject.Parse(json);
      experiment.Name = (string)jsonExperiment["name"];
      var stack = new Stack<StackEntry>();
      var root = new Algorithm();

      if ((bool)jsonExperiment["run"]) {
        experiment.JobDetails = new JobExecutionDetails() {
           Group = (string)jsonExperiment["group"],
           Repititions = (int)jsonExperiment["repititions"]
        };
      }

      foreach (var algo in jsonExperiment["algorithms"]["children"]) {
        stack.Push(new StackEntry(){ Parent = root, Child = algo });
      }

      while (stack.Count > 0) {
        var entry = stack.Pop();
        var data = entry.Child["data"];
        var currentAlgo = data == null ? new Algorithm() : ParseAlgorithm(entry.Child["data"]);
        currentAlgo.Name = (string)entry.Child["name"];
        entry.Parent.ChildAlgorithms.Add(currentAlgo);
        // push children on stack (inverse order to preserve ordering)
        var cnt = entry.Child["children"].Count();
        for (var i=0; i < cnt; i++) {
          stack.Push(new StackEntry() { Parent = currentAlgo, Child = entry.Child["children"][cnt - 1 - i] });
        }
      }

      foreach (var algo in root.ChildAlgorithms) {
        experiment.Algorithm.Add(algo);
      }

      return experiment;
    }
  }
}