using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SemWeb;
using HeuristicLab.GP;
using HeuristicLab.Core;
using HeuristicLab.GP.StructureIdentification;
using System.IO;
using HeuristicLab.Data;
using SVM;
using HeuristicLab.DataAnalysis;

namespace CedmaExporter {
  class CedmaExporter {

    public static List<string> WriteVariableImpactHeaders(Store store, StreamWriter writer) {
      List<string> inputVarNames = new List<string>();
      Statement template = new Statement();
      template.Predicate = Ontology.HasInputVariable;
      var inputVars = store.Select(template).Select(x => x.Object);
      foreach (Entity inputVar in inputVars) {
        var names = store.SelectObjects(inputVar, Ontology.Name);
        if (names.Count() > 0) {
          var inputVarName = ((Literal)names[0]).Value;
          if (!inputVarNames.Contains(inputVarName)) inputVarNames.Add(inputVarName);
        }
      }
      inputVarNames.Sort();
      foreach (string inputVarName in inputVarNames) {
        writer.Write("EvaluationImpact ("); writer.Write(inputVarName); writer.Write("); ");
      }
      foreach (string inputVarName in inputVarNames) {
        writer.Write("QualityImpact ("); writer.Write(inputVarName); writer.Write("); ");
      }
      writer.WriteLine();
      return inputVarNames;
    }

    public static void WriteModel(Entity model, int id, Store store, StreamWriter writer, List<string> inputVariables, ModelExporter exporter) {
      try {
        writer.Write(id); writer.Write("; ");
        string targetVariable = LiteralValue(store.SelectObjects(model, Ontology.TargetVariable)[0]).ToString();
        string algoName = LiteralValue(store.SelectObjects(model, Ontology.Name)[0]).ToString();
        string modelFileName = "model_" + targetVariable + "_" + id.ToString("000");
        writer.Write(modelFileName); writer.Write("; ");
        writer.Write(targetVariable); writer.Write("; ");
        writer.Write(algoName); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TrainingMeanSquaredError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.ValidationMeanSquaredError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TestMeanSquaredError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TrainingCoefficientOfDetermination)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.ValidationCoefficientOfDetermination)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TestCoefficientOfDetermination)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TrainingMeanAbsolutePercentageError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.ValidationMeanAbsolutePercentageError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TestMeanAbsolutePercentageError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TrainingMeanAbsolutePercentageOfRangeError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.ValidationMeanAbsolutePercentageOfRangeError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TestMeanAbsolutePercentageOfRangeError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TrainingVarianceAccountedFor)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.ValidationVarianceAccountedFor)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TestVarianceAccountedFor)[0]).ToString()); writer.Write("; ");
        WriteVariableImpacts(writer, store, model, inputVariables);
        var data = PersistenceManager.RestoreFromGZip(Convert.FromBase64String((string)LiteralValue(store.SelectObjects(model, Ontology.SerializedData)[0])));
        exporter.Export(modelFileName, data);
      }
      catch (FormatException ex) {
        // ignore
      }
      finally {
        writer.WriteLine();
      }
    }

    private static void WriteVariableImpacts(StreamWriter writer, Store store, Entity model, List<string> inputVariables) {
      var inputVariableEntities = store.SelectObjects(model, Ontology.HasInputVariable);
      Dictionary<string, List<double>> impacts = new Dictionary<string, List<double>>();
      foreach (Entity inputVariableEntity in inputVariableEntities) {
        var variableImpacts = new List<double>();
        var names = store.SelectObjects(inputVariableEntity, Ontology.Name);
        if (names.Count() == 0) throw new FormatException();
        impacts[(string)(LiteralValue(names[0]))] = variableImpacts;
        variableImpacts.Add((double)(LiteralValue(store.SelectObjects(inputVariableEntity, Ontology.EvaluationImpact)[0])));
        variableImpacts.Add((double)(LiteralValue(store.SelectObjects(inputVariableEntity, Ontology.QualityImpact)[0])));
      }

      foreach (string varName in inputVariables) {
        if (impacts.ContainsKey(varName)) {
          writer.Write(impacts[varName][0]); writer.Write("; ");
        } else {
          writer.Write(" ; ");
        }
      }

      foreach (string varName in inputVariables) {
        if (impacts.ContainsKey(varName)) {
          writer.Write(impacts[varName][1]); writer.Write("; ");
        } else {
          writer.Write(" ; ");
        }
      }
    }

    public static void WriteColumnHeaders(StreamWriter writer) {
      writer.Write("Id; Filename; TargetVariable; Algorithm;" +
        "TrainingMSE; ValidationMSE; TestMSE; " +
        "TrainingR2; ValidationR2; TestR2; " +
        "TrainingMAPE; ValidationMAPE; TestMAPE; " +
        "TrainingMAPRE; ValidationMAPRE; TestMAPRE; " +
        "TrainingVAF; ValidationVAF; TestVAF; ");
    }

    private static object LiteralValue(Resource resource) {
      return ((Literal)resource).ParseValue();
    }
  }

  class ModelExporter {
    private string outputDir;
    private bool debugging;
    private Dataset dataset;
    IFunctionTreeExporter treeExporter;

    public ModelExporter(Dataset ds, string outputDir, bool debugging) {
      this.dataset = ds;
      this.outputDir = outputDir;
      this.debugging = debugging;
      treeExporter = new SymbolicExpressionExporter(ds);
    }

    public void Export(string modelFileName, IStorable model) {
      if (debugging) return;
      foreach (char c in Path.GetInvalidFileNameChars()) {
        modelFileName = modelFileName.Replace(c, '_');
      }
      if (model is IFunctionTree) {
        using (StreamWriter writer = File.CreateText(Path.Combine(outputDir, modelFileName + ".gp.txt"))) {
          writer.Write(treeExporter.Export((IFunctionTree)model));
        }
      } else if (model is SVMModel) {
        SVMModel svmModel = (SVMModel)model;
        RangeTransform.Write(Path.Combine(outputDir, modelFileName + ".svm.transform.txt"), svmModel.RangeTransform);
        SVM.Model.Write(Path.Combine(outputDir, modelFileName + ".svm.model.txt"), svmModel.Model);
      } else throw new NotSupportedException("This type of model is not supported by the CedmaExporter: " + model);
    }
  }
}