using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Common;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Encodings.BinaryVectorEncoding;
using HeuristicLab.Parameters;
using HeuristicLab.PluginInfrastructure;

namespace HeuristicLab.Problems.NK {

  [Item("LimitedRandomInteractionsInitializer", "Randomly assignes interactions across bits in the vicinity of each other respecting the maximum distances if possible.")]
  [StorableClass]
  public class LimitedRandomInteractionsInitializer : ParameterizedNamedItem, IInteractionInitializer {

    private class Bounds {
      public readonly int Min;
      public readonly int Max;
      public Bounds(int min, int max) {
        Min = Math.Min(min, max);
        Max = Math.Max(min, max);
      }
      public int bounded(int n) {
        return Math.Max(Min, Math.Min(Max, n));
      }
    }

    public ValueParameter<IntValue> MaximumDistanceParameter {
      get { return (ValueParameter<IntValue>)Parameters["MaximumDistance"]; }
    }
    public ValueParameter<DoubleValue> MaximumDistanceRatioParameter {
      get { return (ValueParameter<DoubleValue>)Parameters["MaximumDistanceRatio"]; }
    }    

    private int MaximumDistance(int length, int nInteractions) {
      int maxBitDist = MaximumDistanceParameter.Value.Value;
      double maxDistRatio = MaximumDistanceRatioParameter.Value.Value;
      maxBitDist =  Math.Min(
        maxBitDist == 0 ? length : maxBitDist,
        maxDistRatio == 0 ? length : (int)Math.Round(maxDistRatio*length));      
      if (maxBitDist * 2 < nInteractions)
        maxBitDist = (int)Math.Ceiling(0.5 * nInteractions);
      return maxBitDist;
    }    
        
    [StorableConstructor]
    protected LimitedRandomInteractionsInitializer(bool serializing) : base(serializing) { }
    protected LimitedRandomInteractionsInitializer(LimitedRandomInteractionsInitializer original, Cloner cloner) : base(original, cloner) { }
    public LimitedRandomInteractionsInitializer() {
      Parameters.Add(new ValueParameter<IntValue>("MaximumDistance", "Maximum distance of interactions in bits or 0 for unlimited"));
      Parameters.Add(new ValueParameter<DoubleValue>("MaximumDistanceRatio", "Maximum distance of interactions as ratio of the total length or 0 for unlimited"));
    }
    
    public override IDeepCloneable Clone(Cloner cloner) {
      return new LimitedRandomInteractionsInitializer(this, cloner);
    }    

    #region IInteractionInitializer Members
    public BoolMatrix InitializeInterations(int length, int nComponents, int nInteractions, IRandom random) {
      BoolMatrix m = new BoolMatrix(length, nComponents);
      int maxBitDistance = MaximumDistance(length, nInteractions);
      var minBounds = new Bounds(0, length-nInteractions);
      var maxBounds = new Bounds(nInteractions, length-1);
      for (int c = 0; c<m.Columns; c++) {
        int min = minBounds.bounded(c-maxBitDistance);
        int max = maxBounds.bounded(c+maxBitDistance);
        var indices = Enumerable.Range(min, max-min).ToList();
        indices.Remove(c);
        m[c, c] = true;        
        while (indices.Count > nInteractions) {
          indices.RemoveAt(random.Next(indices.Count));
        }
        foreach (var i in indices) {
          m[i, c] = true;
        }
      }
      return m;      
    }
    #endregion
  }
}