using System;
using HeuristicLab.Algorithms.ALPS;
using HeuristicLab.Algorithms.DataAnalysis;
using HeuristicLab.Algorithms.RandomSearch;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Core.Networks;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.Networks.IntegratedOptimization.SurrogateModeling {
  [Item("Surrogate Modeling Network", "")]
  [Creatable("Optimization Networks")]
  [StorableClass]
  public sealed class SurrogateModelingNetwork : Network {
    #region Nodes
    [Storable]
    private SurrogateModelingOrchestrator orchestrator;
    private SurrogateModelingOrchestrator Orchestrator {
      get { return orchestrator; }
      set {
        if (orchestrator != null)
          throw new InvalidOperationException("Orchestrator has already been initialized.");
        orchestrator = value;
      }
    }

    [Storable]
    private FullEvaluatorNode fullEvaluatorNode;
    private FullEvaluatorNode FullEvaluatorNode {
      get { return fullEvaluatorNode; }
      set {
        if (fullEvaluatorNode != null)
          throw new InvalidOperationException("FullEvaluatorNode has already been initialized.");
        fullEvaluatorNode = value;
      }
    }

    [Storable]
    private OrchestratedAlgorithmNode pointGeneratorNode;
    private OrchestratedAlgorithmNode PointGeneratorNode {
      get { return pointGeneratorNode; }
      set {
        if (pointGeneratorNode != null)
          throw new InvalidOperationException("PointGeneratorNode has already been initialized.");
        pointGeneratorNode = value;
      }
    }

    [Storable]
    private OrchestratedAlgorithmNode modelBuilderNode;
    private OrchestratedAlgorithmNode ModelBuilderNode {
      get { return modelBuilderNode; }
      set {
        if (modelBuilderNode != null)
          throw new InvalidOperationException("ModelBuilderNode has already been initialized.");
        modelBuilderNode = value;
      }
    }

    [Storable]
    private OrchestratedAlgorithmNode assistedOptimizerNode;
    private OrchestratedAlgorithmNode AssistedOptimizerNode {
      get { return assistedOptimizerNode; }
      set {
        if (assistedOptimizerNode != null)
          throw new InvalidOperationException("AssistedOptimizerNode has already been initialized.");
        assistedOptimizerNode = value;
      }
    }
    #endregion

    #region Constructors & Cloning
    [StorableConstructor]
    private SurrogateModelingNetwork(bool deserializing) : base(deserializing) { }
    private SurrogateModelingNetwork(SurrogateModelingNetwork original, Cloner cloner) : base(original, cloner) { }
    public SurrogateModelingNetwork() : this("Surrogate Modeling Network") { }
    public SurrogateModelingNetwork(string name) : this(name, "") { }
    public SurrogateModelingNetwork(string name, string description) : base(name, description) {
      ConfigureOrchestrator();
      ConfigureFullEvaluator();
      ConfigurePointGenerator();
      ConfigureModelBuilder();
      ConfigureAssistedOptimizer();

      Orchestrator.Prepare();
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new SurrogateModelingNetwork(this, cloner);
    }
    #endregion

    private void ConfigureOrchestrator() {
      Orchestrator = new SurrogateModelingOrchestrator();
      Nodes.Add(Orchestrator);
    }

    private void ConfigureFullEvaluator() {
      FullEvaluatorNode = new FullEvaluatorNode();
      Nodes.Add(FullEvaluatorNode);

      Orchestrator.FullEvaluatorOrchPort.ConnectedPort = FullEvaluatorNode.OrchestrationPort;
      Orchestrator.FullEvaluatorExploitationEvalPort.ConnectedPort = FullEvaluatorNode.ExploitationFullEvalRequestPort;
      Orchestrator.FullEvaluatorExplorationEvalPort.ConnectedPort = FullEvaluatorNode.ExplorationFullEvalRequestPort;
      Orchestrator.FullEvaluatorUpdatePort.ConnectedPort = FullEvaluatorNode.UpdateRegressionSolutionPort;
      FullEvaluatorNode.EvaluationPort.CloneParametersFromPort(Orchestrator.FullEvaluatorEvalPort);
      FullEvaluatorNode.EvaluationPort.ConnectedPort = Orchestrator.FullEvaluatorEvalPort;
    }

    private void ConfigurePointGenerator() {
      PointGeneratorNode = new OrchestratedAlgorithmNode("Point Generator") {
        Algorithm = new RandomSearchAlgorithm {
          MaximumEvaluatedSolutions = int.MaxValue
        }
      };
      Nodes.Add(PointGeneratorNode);

      Orchestrator.PointGeneratorOrchPort.ConnectedPort = PointGeneratorNode.OrchestrationPort;
      PointGeneratorNode.EvaluationPort.CloneParametersFromPort(Orchestrator.PointGeneratorEvalPort);
      PointGeneratorNode.EvaluationPort.ConnectedPort = Orchestrator.PointGeneratorEvalPort;
    }

    private void ConfigureModelBuilder() {
      ModelBuilderNode = new OrchestratedAlgorithmNode("Model Builder") {
        Algorithm = new GaussianProcessRegression()
      };
      var updatePort = new ConfigurationPort("Update ProblemData") {
        Parameters = {
          new PortParameter<IRegressionProblemData>("ProblemData") {
            Type = PortParameterType.Input
          }
        }
      };
      ModelBuilderNode.Ports.Add(updatePort);
      Nodes.Add(ModelBuilderNode);

      Orchestrator.ModelBuilderOrchPort.ConnectedPort = ModelBuilderNode.OrchestrationPort;
      Orchestrator.ModelBuilderUpdatePort.ConnectedPort = updatePort;
      ModelBuilderNode.EvaluationPort.CloneParametersFromPort(Orchestrator.ModelBuilderEvalPort);
      ModelBuilderNode.EvaluationPort.ConnectedPort = Orchestrator.ModelBuilderEvalPort;
    }

    private void ConfigureAssistedOptimizer() {
      AssistedOptimizerNode = new OrchestratedAlgorithmNode("Assisted Optimizer") {
        Algorithm = new AlpsGeneticAlgorithm {
          MaximumGenerations = 250,
          ReevaluteElites = true
        }
      };
      var updatePort = new ConfigurationPort("Update RegressionSolution") {
        Parameters = {
          new PortParameter<IRegressionSolution>("RegressionSolution") {
            Type = PortParameterType.Input
          }
        }
      };
      AssistedOptimizerNode.Ports.Add(updatePort);
      Nodes.Add(AssistedOptimizerNode);

      Orchestrator.AssistedOptimizerOrchPort.ConnectedPort = AssistedOptimizerNode.OrchestrationPort;
      Orchestrator.AssistedOptimizerUpdatePort.ConnectedPort = updatePort;
      AssistedOptimizerNode.EvaluationPort.CloneParametersFromPort(Orchestrator.AssistedOptimizerEvalPort);
      AssistedOptimizerNode.EvaluationPort.ConnectedPort = Orchestrator.AssistedOptimizerEvalPort;
    }
  }
}