#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Collections;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.DecisionList;
using HeuristicLab.Optimization.Operators.LCS;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.Problems.DecisionListClassification {
  [StorableClass]
  [Item("DecisionListClassificationProblemData", "")]
  public class DecisionListClassificationProblemData : ParameterizedNamedItem, IDecisionListClassificationProblemData {

    #region default data
    public static string[] defaultVariableNames = new string[] { "a", "b", "c", "d", "e", "f", "g" };
    public static double[,] defaultData = new double[,]{
      {0,0,1,1,0,0,0},
      {0,1,1,1,0,0,0},
      {0,0,1,0,0,0,1},
      {1,0,1,0,1,1,0}
    };
    #endregion

    #region parameter properites
    public IFixedValueParameter<Dataset> DatasetParameter {
      get { return (IFixedValueParameter<Dataset>)Parameters["Dataset"]; }
    }
    public IFixedValueParameter<ReadOnlyCheckedItemList<StringValue>> ConditionVariablesParameter {
      get { return (IFixedValueParameter<ReadOnlyCheckedItemList<StringValue>>)Parameters["ConditionVariables"]; }
    }
    public IConstrainedValueParameter<StringValue> TargetVariableParameter {
      get { return (IConstrainedValueParameter<StringValue>)Parameters["TargetVariable"]; }
    }
    public IFixedValueParameter<IntRange> TrainingPartitionParameter {
      get { return (IFixedValueParameter<IntRange>)Parameters["TrainingPartition"]; }
    }
    public IFixedValueParameter<IntRange> TestPartitionParameter {
      get { return (IFixedValueParameter<IntRange>)Parameters["TestPartition"]; }
    }
    public IValueParameter<Rule> SampleRuleParameter {
      get { return (IValueParameter<Rule>)Parameters["SampleRule"]; }
    }
    public IFixedValueParameter<IntValue> MaxIntervalsParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters["MaxIntervals"]; }
    }
    #endregion

    #region properties
    public Dataset Dataset {
      get { return DatasetParameter.Value; }
    }
    public ICheckedItemList<StringValue> ConditionVariables {
      get { return ConditionVariablesParameter.Value; }
    }
    public StringValue TargetVariable {
      get { return TargetVariableParameter.Value; }
    }
    public IEnumerable<string> AllowedConditionVariables {
      get { return ConditionVariables.CheckedItems.Select(x => x.Value.Value); }
    }
    //public IEnumerable<string> AllowedTargetVariables {
    //  get { return ActionVariables.CheckedItems.Select(x => x.Value.Value); }
    //}
    public IntRange TrainingPartition {
      get { return TrainingPartitionParameter.Value; }
    }
    public IntRange TestPartition {
      get { return TestPartitionParameter.Value; }
    }
    public IEnumerable<int> TrainingIndices {
      get {
        return Enumerable.Range(TrainingPartition.Start, Math.Max(0, TrainingPartition.End - TrainingPartition.Start))
                         .Where(IsTrainingSample);
      }
    }
    public IEnumerable<int> TestIndices {
      get {
        return Enumerable.Range(TestPartition.Start, Math.Max(0, TestPartition.End - TestPartition.Start))
           .Where(IsTestSample);
      }
    }
    public bool IsTrainingSample(int index) {
      return index >= 0 && index < Dataset.Rows &&
        TrainingPartition.Start <= index && index < TrainingPartition.End &&
        (index < TestPartition.Start || TestPartition.End <= index);
    }
    public bool IsTestSample(int index) {
      return index >= 0 && index < Dataset.Rows &&
             TestPartition.Start <= index && index < TestPartition.End;
    }
    public int Classes {
      get { return SampleRuleParameter.Value.Action.Possibilities; }
    }
    #endregion

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      RegisterParameterEvents();
    }
    [StorableConstructor]
    protected DecisionListClassificationProblemData(bool deserializing) : base(deserializing) { }
    protected DecisionListClassificationProblemData(DecisionListClassificationProblemData original, Cloner cloner)
      : base(original, cloner) {
      RegisterParameterEvents();
    }
    public DecisionListClassificationProblemData(Dataset dataset, IEnumerable<string> allowedConditionVariables, string targetVariable) {
      if (dataset == null) throw new ArgumentNullException("The dataset must not be null.");
      if (allowedConditionVariables == null) throw new ArgumentNullException("The allowedActionVariables must not be null.");

      if (allowedConditionVariables.Except(dataset.DoubleVariables).Any())
        throw new ArgumentException("All allowed condition variables must be present in the dataset and of type double.");

      //var validTargetVariableValues = CheckVariablesForPossibleTargetVariables(dataset).Select(x => new StringValue(x).AsReadOnly()).ToList();
      var validTargetVariableValues = dataset.VariableNames.Select(x => new StringValue(x));
      var target = validTargetVariableValues.Where(x => x.Value == targetVariable).DefaultIfEmpty(validTargetVariableValues.First()).First();

      var conditionVariables = new CheckedItemList<StringValue>(dataset.DoubleVariables.Select(x => new StringValue(x)));
      foreach (StringValue x in conditionVariables) {
        conditionVariables.SetItemCheckedState(x, allowedConditionVariables.Contains(x.Value));
      }

      int trainingPartitionStart = 0;
      int trainingPartitionEnd = dataset.Rows / 2;
      int testPartitionStart = dataset.Rows / 2;
      int testPartitionEnd = dataset.Rows;

      Parameters.Add(new FixedValueParameter<Dataset>("Dataset", "", dataset));
      Parameters.Add(new ConstrainedValueParameter<StringValue>("TargetVariable", new ItemSet<StringValue>(validTargetVariableValues), target));
      Parameters.Add(new FixedValueParameter<ReadOnlyCheckedItemList<StringValue>>("ConditionVariables", "", conditionVariables.AsReadOnly()));
      Parameters.Add(new FixedValueParameter<IntRange>("TrainingPartition", "", new IntRange(trainingPartitionStart, trainingPartitionEnd)));
      Parameters.Add(new FixedValueParameter<IntRange>("TestPartition", "", new IntRange(testPartitionStart, testPartitionEnd)));
      Parameters.Add(new FixedValueParameter<IntValue>("MaxIntervals", "", new IntValue(5)));
      Parameters.Add(new ValueParameter<Rule>("SampleRule", "", CreateSampleRule(dataset, conditionVariables.CheckedItems.Select(x => x.Value.Value), target.Value)));

      ((ValueParameter<Dataset>)DatasetParameter).ReactOnValueToStringChangedAndValueItemImageChanged = false;

      RegisterParameterEvents();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new DecisionListClassificationProblemData(this, cloner);
    }

    private Rule CreateSampleRule(Dataset dataset, IEnumerable<string> conditionVariables, string target) {
      IEnumerable<HeuristicLab.Encodings.DecisionList.IVariable> condition = GetConditionOfDataSet(dataset, conditionVariables);
      IAction action = GetActionOfDataset(dataset, target);
      return new Rule(condition, action);
    }

    private IAction GetActionOfDataset(DataAnalysis.Dataset dataset, string target) {
      IAction action = null;
      var variableValues = dataset.GetValues(target);
      if (variableValues is List<string>) {
        action = new StringAction(target, (variableValues as List<string>).Distinct().ToList());
      } else if (variableValues is List<double>) {
        var doubleValues = (variableValues as List<double>).Distinct();
        if (doubleValues.All(x => x % 1 == 0)) {
          action = new IntAction(target, doubleValues.Select(x => Convert.ToInt32(x)).ToList());
        } else {
          throw new ArgumentException("The target variable contains double values. Therefore it can't be used as target");
        }
      } else {
        throw new ArgumentException("There is no matching variable type for the values in the dataset");
      }
      return action;
    }

    private IEnumerable<Encodings.DecisionList.IVariable> GetConditionOfDataSet(DataAnalysis.Dataset dataset, IEnumerable<string> conditionVariables) {
      var condition = new List<HeuristicLab.Encodings.DecisionList.IVariable>();
      foreach (var variableName in conditionVariables) {
        var variableValues = dataset.GetValues(variableName);
        HeuristicLab.Encodings.DecisionList.IVariable variable;
        if (variableValues is List<string>) {
          variable = new StringVariable(variableName, (variableValues as List<string>).Distinct().ToList());
        } else if (variableValues is List<double>) {
          var doubleValues = (variableValues as List<double>).Distinct();
          if (doubleValues.All(x => x % 1 == 0)) {
            // ToList call is necessary, because otherwise it wouldn't be possible to serialize it
            variable = new IntVariable(variableName, doubleValues.Select(x => Convert.ToInt32(x)).ToList());
          } else {
            variable = new DoubleVariable(variableName, MaxIntervalsParameter.Value.Value);
          }
        } else {
          throw new ArgumentException("There is no matching variable type for the values in the dataset");
        }
        condition.Add(variable);
      }
      return condition;
    }

    public IEnumerable<DecisionListInput> FetchInput(IEnumerable<int> rows) {
      foreach (var row in rows) {
        yield return FetchInput(row);
      }
    }

    protected IDictionary<int, DecisionListInput> fetchInputCache = new Dictionary<int, DecisionListInput>();
    public DecisionListInput FetchInput(int row) {
      if (!fetchInputCache.ContainsKey(row)) {
        DecisionListInput input = new DecisionListInput();
        var variableNames = SampleRuleParameter.Value.Variables.Keys.ToList();
        variableNames.Add(SampleRuleParameter.Value.Action.VariableName);
        foreach (var variableName in variableNames) {
          input.InputDictionary.Add(variableName, Dataset.GetValue(row, variableName));
        }
        fetchInputCache.Add(row, input);
      }
      return fetchInputCache[row];
    }

    public IEnumerable<IAction> FetchAction(IEnumerable<int> rows) {
      foreach (var row in rows) {
        yield return FetchAction(row);
      }
    }
    protected IDictionary<int, IAction> fetchActionCache = new Dictionary<int, IAction>();
    public IAction FetchAction(int row) {
      if (!fetchActionCache.ContainsKey(row)) {
        var action = (IAction)SampleRuleParameter.Value.Action.Clone();
        action.SetTo(Dataset.GetValue(row, action.VariableName));
        fetchActionCache.Add(row, action);
      }
      return fetchActionCache[row];
    }

    protected IList<IGAssistNiche> possibleNiches;
    public IEnumerable<IGAssistNiche> GetPossibleNiches() {
      if (possibleNiches == null) {
        possibleNiches = new List<IGAssistNiche>();
        for (int i = 0; i < Dataset.Rows; i++) {
          var action = FetchAction(i);
          if (!possibleNiches.Any(x => x.SameNiche(action))) {
            possibleNiches.Add(action);
          }
        }
      }
      return possibleNiches;
    }

    public event EventHandler Changed;

    #region events
    private void RegisterParameterEvents() {
      ConditionVariablesParameter.ValueChanged += new EventHandler(VariablesChanged);
      ConditionVariablesParameter.Value.CheckedItemsChanged += new CollectionItemsChangedEventHandler<IndexedItem<StringValue>>(VariablesChanged);
      TargetVariableParameter.ValueChanged += new EventHandler(VariablesChanged);
    }
    private void DeregisterParameterEvents() {
      TargetVariableParameter.ValueChanged += new EventHandler(VariablesChanged);
      ConditionVariablesParameter.Value.CheckedItemsChanged += new CollectionItemsChangedEventHandler<IndexedItem<StringValue>>(VariablesChanged);
      ConditionVariablesParameter.ValueChanged += new EventHandler(VariablesChanged);
    }
    private void Value_CheckedItemsChanged(object sender, CollectionItemsChangedEventArgs<IndexedItem<StringValue>> e) {
      VariablesChanged();
    }
    private void VariablesChanged(object sender, EventArgs e) {
      VariablesChanged();
    }

    private void VariablesChanged() {
      SampleRuleParameter.Value = CreateSampleRule(Dataset, AllowedConditionVariables, TargetVariable.Value);
    }
    #endregion
  }
}