package org.apache.samoa.moa.streams.clustering;

/*
 * #%L
 * SAMOA
 * %%
 * Copyright (C) 2014 - 2015 Apache Software Foundation
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.LinkedList;
import java.util.Random;
import java.util.Vector;

import org.apache.samoa.instances.Attribute;
import org.apache.samoa.instances.DenseInstance;
import org.apache.samoa.instances.Instance;
import org.apache.samoa.instances.Instances;
import org.apache.samoa.instances.InstancesHeader;
import org.apache.samoa.moa.cluster.Clustering;
import org.apache.samoa.moa.cluster.SphereCluster;
import org.apache.samoa.moa.core.AutoExpandVector;
import org.apache.samoa.moa.core.DataPoint;
import org.apache.samoa.moa.core.FastVector;
import org.apache.samoa.moa.core.InstanceExample;
import org.apache.samoa.moa.core.ObjectRepository;
import org.apache.samoa.moa.streams.InstanceStream;
import org.apache.samoa.moa.tasks.TaskMonitor;

import com.github.javacliparser.FlagOption;
import com.github.javacliparser.FloatOption;
import com.github.javacliparser.IntOption;

public class RandomRBFGeneratorEvents extends ClusteringStream {
  private transient Vector listeners;

  private static final long serialVersionUID = 1L;

  public IntOption modelRandomSeedOption = new IntOption("modelRandomSeed",
      'm', "Seed for random generation of model.", 1);

  public IntOption instanceRandomSeedOption = new IntOption(
      "instanceRandomSeed", 'i',
      "Seed for random generation of instances.", 5);

  public IntOption numClusterOption = new IntOption("numCluster", 'K',
      "The average number of centroids in the model.", 5, 1, Integer.MAX_VALUE);

  public IntOption numClusterRangeOption = new IntOption("numClusterRange", 'k',
      "Deviation of the number of centroids in the model.", 3, 0, Integer.MAX_VALUE);

  public FloatOption kernelRadiiOption = new FloatOption("kernelRadius", 'R',
      "The average radii of the centroids in the model.", 0.07, 0, 1);

  public FloatOption kernelRadiiRangeOption = new FloatOption("kernelRadiusRange", 'r',
      "Deviation of average radii of the centroids in the model.", 0, 0, 1);

  public FloatOption densityRangeOption = new FloatOption("densityRange", 'd',
      "Offset of the average weight a cluster has. Value of 0 means all cluster " +
          "contain the same amount of points.", 0, 0, 1);

  public IntOption speedOption = new IntOption("speed", 'V',
      "Kernels move a predefined distance of 0.01 every X points", 500, 1, Integer.MAX_VALUE);

  public IntOption speedRangeOption = new IntOption("speedRange", 'v',
      "Speed/Velocity point offset", 0, 0, Integer.MAX_VALUE);

  public FloatOption noiseLevelOption = new FloatOption("noiseLevel", 'N',
      "Noise level", 0.1, 0, 1);

  public FlagOption noiseInClusterOption = new FlagOption("noiseInCluster", 'n',
      "Allow noise to be placed within a cluster");

  public IntOption eventFrequencyOption = new IntOption("eventFrequency", 'E',
      "Event frequency. Enable at least one of the events below and set numClusterRange!", 30000, 0, Integer.MAX_VALUE);

  public FlagOption eventMergeSplitOption = new FlagOption("eventMergeSplitOption", 'M',
      "Enable merging and splitting of clusters. Set eventFrequency and numClusterRange!");

  public FlagOption eventDeleteCreateOption = new FlagOption("eventDeleteCreate", 'C',
      "Enable emering and disapperaing of clusters. Set eventFrequency and numClusterRange!");

  private double merge_threshold = 0.7;
  private int kernelMovePointFrequency = 10;
  private double maxDistanceMoveThresholdByStep = 0.01;
  private int maxOverlapFitRuns = 50;
  private double eventFrequencyRange = 0;

  private boolean debug = false;

  private AutoExpandVector<GeneratorCluster> kernels;
  protected Random instanceRandom;
  protected InstancesHeader streamHeader;
  private int numGeneratedInstances;
  private int numActiveKernels;
  private int nextEventCounter;
  private int nextEventChoice = -1;
  private int clusterIdCounter;
  private GeneratorCluster mergeClusterA;
  private GeneratorCluster mergeClusterB;
  private boolean mergeKernelsOverlapping = false;

  private class GeneratorCluster implements Serializable {
    // TODO: points is redundant to microclusterpoints, we need to come
    // up with a good strategy that microclusters get updated and
    // rebuild if needed. Idea: Sort microclusterpoints by timestamp and let
    // microclusterdecay hold the timestamp for when the last point in a
    // microcluster gets kicked, then we rebuild... or maybe not... could be
    // same as searching for point to be kicked. more likely is we rebuild
    // fewer times then insert.

    private static final long serialVersionUID = -6301649898961112942L;

    SphereCluster generator;
    int kill = -1;
    boolean merging = false;
    double[] moveVector;
    int totalMovementSteps;
    int currentMovementSteps;
    boolean isSplitting = false;

    LinkedList<DataPoint> points = new LinkedList<DataPoint>();
    ArrayList<SphereCluster> microClusters = new ArrayList<SphereCluster>();
    ArrayList<ArrayList<DataPoint>> microClustersPoints = new ArrayList();
    ArrayList<Integer> microClustersDecay = new ArrayList();

    public GeneratorCluster(int label) {
      boolean outofbounds = true;
      int tryCounter = 0;
      while (outofbounds && tryCounter < maxOverlapFitRuns) {
        tryCounter++;
        outofbounds = false;
        double[] center = new double[numAttsOption.getValue()];
        double radius = kernelRadiiOption.getValue() + (instanceRandom.nextBoolean() ? -1 : 1)
            * kernelRadiiRangeOption.getValue() * instanceRandom.nextDouble();
        while (radius <= 0) {
          radius = kernelRadiiOption.getValue() + (instanceRandom.nextBoolean() ? -1 : 1)
              * kernelRadiiRangeOption.getValue() * instanceRandom.nextDouble();
        }
        for (int j = 0; j < numAttsOption.getValue(); j++) {
          center[j] = instanceRandom.nextDouble();
          if (center[j] - radius < 0 || center[j] + radius > 1) {
            outofbounds = true;
            break;
          }
        }
        generator = new SphereCluster(center, radius);
      }
      if (tryCounter < maxOverlapFitRuns) {
        generator.setId(label);
        double avgWeight = 1.0 / numClusterOption.getValue();
        double weight = avgWeight + (instanceRandom.nextBoolean() ? -1 : 1) * avgWeight * densityRangeOption.getValue()
            * instanceRandom.nextDouble();
        generator.setWeight(weight);
        setDesitnation(null);
      }
      else {
        generator = null;
        kill = 0;
        System.out.println("Tried " + maxOverlapFitRuns + " times to create kernel. Reduce average radii.");
      }
    }

    public GeneratorCluster(int label, SphereCluster cluster) {
      this.generator = cluster;
      cluster.setId(label);
      setDesitnation(null);
    }

    public int getWorkID() {
      for (int c = 0; c < kernels.size(); c++) {
        if (kernels.get(c).equals(this))
          return c;
      }
      return -1;
    }

    private void updateKernel() {
      if (kill == 0) {
        kernels.remove(this);
      }
      if (kill > 0) {
        kill--;
      }
      // we could be lot more precise if we would keep track of timestamps of
      // points
      // then we could remove all old points and rebuild the cluster on up to
      // date point base
      // BUT worse the effort??? so far we just want to avoid overlap with this,
      // so its more
      // konservative as needed. Only needs to change when we need a thighter
      // representation
      for (int m = 0; m < microClusters.size(); m++) {
        if (numGeneratedInstances - microClustersDecay.get(m) > decayHorizonOption.getValue()) {
          microClusters.remove(m);
          microClustersPoints.remove(m);
          microClustersDecay.remove(m);
        }
      }

      if (!points.isEmpty()
          && numGeneratedInstances - points.getFirst().getTimestamp() >= decayHorizonOption.getValue()) {
        // if(debug)
        // System.out.println("Cleaning up macro cluster "+generator.getId());
        points.removeFirst();
      }

    }

    private void addInstance(Instance instance) {
      DataPoint point = new DataPoint(instance, numGeneratedInstances);
      points.add(point);

      int minMicroIndex = -1;
      double minHullDist = Double.MAX_VALUE;
      boolean inserted = false;
      // we favour more recently build clusters so we can remove earlier cluster
      // sooner
      for (int m = microClusters.size() - 1; m >= 0; m--) {
        SphereCluster micro = microClusters.get(m);
        double hulldist = micro.getCenterDistance(point) - micro.getRadius();
        // point fits into existing cluster
        if (hulldist <= 0) {
          microClustersPoints.get(m).add(point);
          microClustersDecay.set(m, numGeneratedInstances);
          inserted = true;
          break;
        }
        // if not, check if its at least the closest cluster
        else {
          if (hulldist < minHullDist) {
            minMicroIndex = m;
            minHullDist = hulldist;
          }
        }
      }
      // Reseting index choice for alternative cluster building
      int alt = 1;
      if (alt == 1)
        minMicroIndex = -1;
      if (!inserted) {
        // add to closest cluster and expand cluster
        if (minMicroIndex != -1) {
          microClustersPoints.get(minMicroIndex).add(point);
          // we should keep the miniball instances and just check in
          // new points instead of rebuilding the whole thing
          SphereCluster s = new SphereCluster(microClustersPoints.get(minMicroIndex), numAttsOption.getValue());
          // check if current microcluster is bigger then generating cluster
          if (s.getRadius() > generator.getRadius()) {
            // remove previously added point
            microClustersPoints.get(minMicroIndex).remove(microClustersPoints.get(minMicroIndex).size() - 1);
            minMicroIndex = -1;
          }
          else {
            microClusters.set(minMicroIndex, s);
            microClustersDecay.set(minMicroIndex, numGeneratedInstances);
          }
        }
        // minMicroIndex might have been reset above
        // create new micro cluster
        if (minMicroIndex == -1) {
          ArrayList<DataPoint> microPoints = new ArrayList<DataPoint>();
          microPoints.add(point);
          SphereCluster s;
          if (alt == 0)
            s = new SphereCluster(microPoints, numAttsOption.getValue());
          else
            s = new SphereCluster(generator.getCenter(), generator.getRadius(), 1);

          microClusters.add(s);
          microClustersPoints.add(microPoints);
          microClustersDecay.add(numGeneratedInstances);
          int id = 0;
          while (id < kernels.size()) {
            if (kernels.get(id) == this)
              break;
            id++;
          }
          s.setGroundTruth(id);
        }
      }

    }

    private void move() {
      if (currentMovementSteps < totalMovementSteps) {
        currentMovementSteps++;
        if (moveVector == null) {
          return;
        }
        else {
          double[] center = generator.getCenter();
          boolean outofbounds = true;
          while (outofbounds) {
            double radius = generator.getRadius();
            outofbounds = false;
            center = generator.getCenter();
            for (int d = 0; d < center.length; d++) {
              center[d] += moveVector[d];
              if (center[d] - radius < 0 || center[d] + radius > 1) {
                outofbounds = true;
                setDesitnation(null);
                break;
              }
            }
          }
          generator.setCenter(center);
        }
      }
      else {
        if (!merging) {
          setDesitnation(null);
          isSplitting = false;
        }
      }
    }

    void setDesitnation(double[] destination) {

      if (destination == null) {
        destination = new double[numAttsOption.getValue()];
        for (int j = 0; j < numAttsOption.getValue(); j++) {
          destination[j] = instanceRandom.nextDouble();
        }
      }
      double[] center = generator.getCenter();
      int dim = center.length;

      double[] v = new double[dim];

      for (int d = 0; d < dim; d++) {
        v[d] = destination[d] - center[d];
      }
      setMoveVector(v);
    }

    void setMoveVector(double[] vector) {
      // we are ignoring the steps, otherwise we have to change
      // speed of the kernels, do we want that?
      moveVector = vector;
      int speedInPoints = speedOption.getValue();
      if (speedRangeOption.getValue() > 0)
        speedInPoints += (instanceRandom.nextBoolean() ? -1 : 1) * instanceRandom.nextInt(speedRangeOption.getValue());
      if (speedInPoints < 1)
        speedInPoints = speedOption.getValue();

      double length = 0;
      for (int d = 0; d < moveVector.length; d++) {
        length += Math.pow(vector[d], 2);
      }
      length = Math.sqrt(length);

      totalMovementSteps = (int) (length / (maxDistanceMoveThresholdByStep * kernelMovePointFrequency) * speedInPoints);
      for (int d = 0; d < moveVector.length; d++) {
        moveVector[d] /= (double) totalMovementSteps;
      }

      currentMovementSteps = 0;
      // if(debug){
      // System.out.println("Setting new direction for C"+generator.getId()+": distance "
      // +length+" in "+totalMovementSteps+" steps");
      // }
    }

    private String tryMerging(GeneratorCluster merge) {
      String message = "";
      double overlapDegree = generator.overlapRadiusDegree(merge.generator);
      if (overlapDegree > merge_threshold) {
        SphereCluster mcluster = merge.generator;
        double radius = Math.max(generator.getRadius(), mcluster.getRadius());
        generator.combine(mcluster);

        // //adjust radius, get bigger and bigger with high dim data
        generator.setRadius(radius);
        // double[] center = generator.getCenter();
        // double[] mcenter = mcluster.getCenter();
        // double weight = generator.getWeight();
        // double mweight = generator.getWeight();
        // // for (int i = 0; i < center.length; i++) {
        // // center[i] = (center[i] * weight + mcenter[i] * mweight) / (mweight
        // + weight);
        // // }
        // generator.setWeight(weight + mweight);
        message = "Clusters merging: " + mergeClusterB.generator.getId() + " into " + mergeClusterA.generator.getId();

        // clean up and restet merging stuff
        // mark kernel so it gets killed when it doesn't contain any more
        // instances
        merge.kill = decayHorizonOption.getValue();
        // set weight to 0 so no new instances will be created in the cluster
        mcluster.setWeight(0.0);
        normalizeWeights();
        numActiveKernels--;
        mergeClusterB = mergeClusterA = null;
        merging = false;
        mergeKernelsOverlapping = false;
      }
      else {
        if (overlapDegree > 0 && !mergeKernelsOverlapping) {
          mergeKernelsOverlapping = true;
          message = "Merge overlapping started";
        }
      }
      return message;
    }

    private String splitKernel() {
      isSplitting = true;
      // todo radius range
      double radius = kernelRadiiOption.getValue();
      double avgWeight = 1.0 / numClusterOption.getValue();
      double weight = avgWeight + avgWeight * densityRangeOption.getValue() * instanceRandom.nextDouble();
      SphereCluster spcluster = null;

      double[] center = generator.getCenter();
      spcluster = new SphereCluster(center, radius, weight);

      if (spcluster != null) {
        GeneratorCluster gc = new GeneratorCluster(clusterIdCounter++, spcluster);
        gc.isSplitting = true;
        kernels.add(gc);
        normalizeWeights();
        numActiveKernels++;
        return "Split from Kernel " + generator.getId();
      }
      else {
        System.out.println("Tried to split new kernel from C" + generator.getId() +
            ". Not enough room for new cluster, decrease average radii, number of clusters or enable overlap.");
        return "";
      }
    }

    private String fadeOut() {
      kill = decayHorizonOption.getValue();
      generator.setWeight(0.0);
      numActiveKernels--;
      normalizeWeights();
      return "Fading out C" + generator.getId();
    }

  }

  public RandomRBFGeneratorEvents() {
    noiseInClusterOption.set();
    // eventDeleteCreateOption.set();
    // eventMergeSplitOption.set();
  }

  public InstancesHeader getHeader() {
    return streamHeader;
  }

  public long estimatedRemainingInstances() {
    return -1;
  }

  public boolean hasMoreInstances() {
    return true;
  }

  public boolean isRestartable() {
    return true;
  }

  @Override
  public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
    monitor.setCurrentActivity("Preparing random RBF...", -1.0);
    generateHeader();
    restart();
  }

  public void restart() {
    instanceRandom = new Random(instanceRandomSeedOption.getValue());
    nextEventCounter = eventFrequencyOption.getValue();
    nextEventChoice = getNextEvent();
    numActiveKernels = 0;
    numGeneratedInstances = 0;
    clusterIdCounter = 0;
    mergeClusterA = mergeClusterB = null;
    kernels = new AutoExpandVector<GeneratorCluster>();

    initKernels();
  }

  protected void generateHeader() { // 2013/06/02: Noise label
    ArrayList<Attribute> attributes = new ArrayList<Attribute>();
    for (int i = 0; i < this.numAttsOption.getValue(); i++) {
      attributes.add(new Attribute("att" + (i + 1)));
    }

    ArrayList<String> classLabels = new ArrayList<String>();
    for (int i = 0; i < this.numClusterOption.getValue(); i++) {
      classLabels.add("class" + (i + 1));
    }
    if (noiseLevelOption.getValue() > 0)
      classLabels.add("noise"); // The last label = "noise"

    attributes.add(new Attribute("class", classLabels));
    streamHeader = new InstancesHeader(new Instances(getCLICreationString(InstanceStream.class), attributes, 0));
    streamHeader.setClassIndex(streamHeader.numAttributes() - 1);
  }

  protected void initKernels() {
    for (int i = 0; i < numClusterOption.getValue(); i++) {
      kernels.add(new GeneratorCluster(clusterIdCounter));
      numActiveKernels++;
      clusterIdCounter++;
    }
    normalizeWeights();
  }

  public InstanceExample nextInstance() {
    numGeneratedInstances++;
    eventScheduler();

    // make room for the classlabel
    double[] values_new = new double[numAttsOption.getValue()]; // +1
    double[] values = null;
    int clusterChoice = -1;

    if (instanceRandom.nextDouble() > noiseLevelOption.getValue()) {
      clusterChoice = chooseWeightedElement();
      values = kernels.get(clusterChoice).generator.sample(instanceRandom).toDoubleArray();
    }
    else {
      // get ranodm noise point
      values = getNoisePoint();
    }

    if (Double.isNaN(values[0])) {
      System.out.println("Instance corrupted:" + numGeneratedInstances);
    }
    System.arraycopy(values, 0, values_new, 0, values.length);

    Instance inst = new DenseInstance(1.0, values_new);
    inst.setDataset(getHeader());
    if (clusterChoice == -1) {
      // 2013/06/02 (Yunsu Kim)
      // Noise instance has the last class value instead of "-1"
      // Preventing ArrayIndexOutOfBoundsException in WriteStreamToARFFFile
      inst.setClassValue(numClusterOption.getValue());
    }
    else {
      inst.setClassValue(kernels.get(clusterChoice).generator.getId());
      // Do we need micro cluster representation if have overlapping clusters?
      // if(!overlappingOption.isSet())
      kernels.get(clusterChoice).addInstance(inst);
    }
    // System.out.println(numGeneratedInstances+": Overlap is"+updateOverlaps());

    return new InstanceExample(inst);
  }

  public Clustering getGeneratingClusters() {
    Clustering clustering = new Clustering();
    for (int c = 0; c < kernels.size(); c++) {
      clustering.add(kernels.get(c).generator);
    }
    return clustering;
  }

  public Clustering getMicroClustering() {
    Clustering clustering = new Clustering();
    int id = 0;

    for (int c = 0; c < kernels.size(); c++) {
      for (int m = 0; m < kernels.get(c).microClusters.size(); m++) {
        kernels.get(c).microClusters.get(m).setId(id);
        kernels.get(c).microClusters.get(m).setGroundTruth(kernels.get(c).generator.getId());
        clustering.add(kernels.get(c).microClusters.get(m));
        id++;
      }
    }

    // System.out.println("numMicroKernels "+clustering.size());
    return clustering;
  }

  /**************************** EVENTS ******************************************/
  private void eventScheduler() {

    for (int i = 0; i < kernels.size(); i++) {
      kernels.get(i).updateKernel();
    }

    nextEventCounter--;
    // only move kernels every 10 points, performance reasons????
    // should this be randomized as well???
    if (nextEventCounter % kernelMovePointFrequency == 0) {
      // move kernels
      for (int i = 0; i < kernels.size(); i++) {
        kernels.get(i).move();
        // overlapControl();
      }
    }

    if (eventFrequencyOption.getValue() == 0) {
      return;
    }

    String type = "";
    String message = "";
    boolean eventFinished = false;
    switch (nextEventChoice) {
    case 0:
      if (numActiveKernels > 1 && numActiveKernels > numClusterOption.getValue() - numClusterRangeOption.getValue()) {
        message = mergeKernels(nextEventCounter);
        type = "Merge";
      }
      if (mergeClusterA == null && mergeClusterB == null && message.startsWith("Clusters merging")) {
        eventFinished = true;
      }
      break;
    case 1:
      if (nextEventCounter <= 0) {
        if (numActiveKernels < numClusterOption.getValue() + numClusterRangeOption.getValue()) {
          type = "Split";
          message = splitKernel();
        }
        eventFinished = true;
      }
      break;
    case 2:
      if (nextEventCounter <= 0) {
        if (numActiveKernels > 1 && numActiveKernels > numClusterOption.getValue() - numClusterRangeOption.getValue()) {
          message = fadeOut();
          type = "Delete";
        }
        eventFinished = true;
      }
      break;
    case 3:
      if (nextEventCounter <= 0) {
        if (numActiveKernels < numClusterOption.getValue() + numClusterRangeOption.getValue()) {
          message = fadeIn();
          type = "Create";
        }
        eventFinished = true;
      }
      break;

    }
    if (eventFinished) {
      nextEventCounter = (int) (eventFrequencyOption.getValue() + (instanceRandom.nextBoolean() ? -1 : 1)
          * eventFrequencyOption.getValue() * eventFrequencyRange * instanceRandom.nextDouble());
      nextEventChoice = getNextEvent();
      // System.out.println("Next event choice: "+nextEventChoice);
    }
    if (!message.isEmpty()) {
      message += " (numKernels = " + numActiveKernels + " at " + numGeneratedInstances + ")";
      if (!type.equals("Merge") || message.startsWith("Clusters merging"))
        fireClusterChange(numGeneratedInstances, type, message);
    }
  }

  private int getNextEvent() {
    int choice = -1;
    boolean lowerLimit = numActiveKernels <= numClusterOption.getValue() - numClusterRangeOption.getValue();
    boolean upperLimit = numActiveKernels >= numClusterOption.getValue() + numClusterRangeOption.getValue();

    if (!lowerLimit || !upperLimit) {
      int mode = -1;
      if (eventDeleteCreateOption.isSet() && eventMergeSplitOption.isSet()) {
        mode = instanceRandom.nextInt(2);
      }

      if (mode == 0 || (mode == -1 && eventMergeSplitOption.isSet())) {
        // have we reached a limit? if not free choice
        if (!lowerLimit && !upperLimit)
          choice = instanceRandom.nextInt(2);
        else
        // we have a limit. if lower limit, choose split
        if (lowerLimit)
          choice = 1;
        // otherwise we reached upper level, choose merge
        else
          choice = 0;
      }

      if (mode == 1 || (mode == -1 && eventDeleteCreateOption.isSet())) {
        // have we reached a limit? if not free choice
        if (!lowerLimit && !upperLimit)
          choice = instanceRandom.nextInt(2) + 2;
        else
        // we have a limit. if lower limit, choose create
        if (lowerLimit)
          choice = 3;
        // otherwise we reached upper level, choose delete
        else
          choice = 2;
      }
    }

    return choice;
  }

  private String fadeOut() {
    int id = instanceRandom.nextInt(kernels.size());
    while (kernels.get(id).kill != -1)
      id = instanceRandom.nextInt(kernels.size());

    String message = kernels.get(id).fadeOut();
    return message;
  }

  private String fadeIn() {
    GeneratorCluster gc = new GeneratorCluster(clusterIdCounter++);
    kernels.add(gc);
    numActiveKernels++;
    normalizeWeights();
    return "Creating new cluster";
  }

  private String changeWeight(boolean increase) {
    double changeRate = 0.1;
    int id = instanceRandom.nextInt(kernels.size());
    while (kernels.get(id).kill != -1)
      id = instanceRandom.nextInt(kernels.size());

    int sign = 1;
    if (!increase)
      sign = -1;
    double weight_old = kernels.get(id).generator.getWeight();
    double delta = sign * numActiveKernels * instanceRandom.nextDouble() * changeRate;
    kernels.get(id).generator.setWeight(weight_old + delta);

    normalizeWeights();

    String message;
    if (increase)
      message = "Increase ";
    else
      message = "Decrease ";
    message += " weight on Cluster " + id + " from " + weight_old + " to " + (weight_old + delta);
    return message;

  }

  private String changeRadius(boolean increase) {
    double maxChangeRate = 0.1;
    int id = instanceRandom.nextInt(kernels.size());
    while (kernels.get(id).kill != -1)
      id = instanceRandom.nextInt(kernels.size());

    int sign = 1;
    if (!increase)
      sign = -1;

    double r_old = kernels.get(id).generator.getRadius();
    double r_new = r_old + sign * r_old * instanceRandom.nextDouble() * maxChangeRate;
    if (r_new >= 0.5)
      return "Radius to big";
    kernels.get(id).generator.setRadius(r_new);

    String message;
    if (increase)
      message = "Increase ";
    else
      message = "Decrease ";
    message += " radius on Cluster " + id + " from " + r_old + " to " + r_new;
    return message;
  }

  private String splitKernel() {
    int id = instanceRandom.nextInt(kernels.size());
    while (kernels.get(id).kill != -1)
      id = instanceRandom.nextInt(kernels.size());

    String message = kernels.get(id).splitKernel();

    return message;
  }

  private String mergeKernels(int steps) {
    if (numActiveKernels > 1 && ((mergeClusterA == null && mergeClusterB == null))) {

      // choose clusters to merge
      double diseredDist = steps / speedOption.getValue() * maxDistanceMoveThresholdByStep;
      double minDist = Double.MAX_VALUE;
      // System.out.println("DisredDist:"+(2*diseredDist));
      for (int i = 0; i < kernels.size(); i++) {
        for (int j = 0; j < i; j++) {
          if (kernels.get(i).kill != -1 || kernels.get(j).kill != -1) {
            continue;
          }
          else {
            double kernelDist = kernels.get(i).generator.getCenterDistance(kernels.get(j).generator);
            double d = kernelDist - 2 * diseredDist;
            // System.out.println("Dist:"+i+" / "+j+" "+d);
            if (Math.abs(d) < minDist &&
                (minDist != Double.MAX_VALUE || d > 0 || Math.abs(d) < 0.001)) {
              minDist = Math.abs(d);
              mergeClusterA = kernels.get(i);
              mergeClusterB = kernels.get(j);
            }
          }
        }
      }

      if (mergeClusterA != null && mergeClusterB != null) {
        double[] merge_point = mergeClusterA.generator.getCenter();
        double[] v = mergeClusterA.generator.getDistanceVector(mergeClusterB.generator);
        for (int i = 0; i < v.length; i++) {
          merge_point[i] = merge_point[i] + v[i] * 0.5;
        }

        mergeClusterA.merging = true;
        mergeClusterB.merging = true;
        mergeClusterA.setDesitnation(merge_point);
        mergeClusterB.setDesitnation(merge_point);

        if (debug) {
          System.out.println("Center1" + Arrays.toString(mergeClusterA.generator.getCenter()));
          System.out.println("Center2" + Arrays.toString(mergeClusterB.generator.getCenter()));
          System.out.println("Vector" + Arrays.toString(v));

          System.out.println("Try to merge cluster " + mergeClusterA.generator.getId() +
              " into " + mergeClusterB.generator.getId() +
              " at " + Arrays.toString(merge_point) +
              " time " + numGeneratedInstances);
        }
        return "Init merge";
      }
    }

    if (mergeClusterA != null && mergeClusterB != null) {

      // movekernels will move the kernels close to each other,
      // we just need to check and merge here if they are close enough
      return mergeClusterA.tryMerging(mergeClusterB);
    }

    return "";
  }

  /************************* TOOLS **************************************/

  public void getDescription(StringBuilder sb, int indent) {

  }

  private double[] getNoisePoint() {
    double[] sample = new double[numAttsOption.getValue()];
    boolean incluster = true;
    int counter = 20;
    while (incluster) {
      for (int j = 0; j < numAttsOption.getValue(); j++) {
        sample[j] = instanceRandom.nextDouble();
      }
      incluster = false;
      if (!noiseInClusterOption.isSet() && counter > 0) {
        counter--;
        for (int c = 0; c < kernels.size(); c++) {
          for (int m = 0; m < kernels.get(c).microClusters.size(); m++) {
            Instance inst = new DenseInstance(1, sample);
            if (kernels.get(c).microClusters.get(m).getInclusionProbability(inst) > 0) {
              incluster = true;
              break;
            }
          }
          if (incluster)
            break;
        }
      }
    }

    // double [] sample = new double [numAttsOption.getValue()];
    // for (int j = 0; j < numAttsOption.getValue(); j++) {
    // sample[j] = instanceRandom.nextDouble();
    // }

    return sample;
  }

  private int chooseWeightedElement() {
    double r = instanceRandom.nextDouble();

    // Determine index of choosen element
    int i = 0;
    while (r > 0.0) {
      r -= kernels.get(i).generator.getWeight();
      i++;
    }
    --i; // Overcounted once
    // System.out.println(i);
    return i;
  }

  private void normalizeWeights() {
    double sumWeights = 0.0;
    for (int i = 0; i < kernels.size(); i++) {
      sumWeights += kernels.get(i).generator.getWeight();
    }
    for (int i = 0; i < kernels.size(); i++) {
      kernels.get(i).generator.setWeight(kernels.get(i).generator.getWeight() / sumWeights);
    }
  }

  /*************** EVENT Listener *********************/
  // should go into the superclass of the generator, create new one for cluster
  // streams?

  /** Add a listener */
  synchronized public void addClusterChangeListener(ClusterEventListener l) {
    if (listeners == null)
      listeners = new Vector();
    listeners.addElement(l);
  }

  /** Remove a listener */
  synchronized public void removeClusterChangeListener(ClusterEventListener l) {
    if (listeners == null)
      listeners = new Vector();
    listeners.removeElement(l);
  }

  /** Fire a ClusterChangeEvent to all registered listeners */
  protected void fireClusterChange(long timestamp, String type, String message) {
    // if we have no listeners, do nothing...
    if (listeners != null && !listeners.isEmpty()) {
      // create the event object to send
      ClusterEvent event =
          new ClusterEvent(this, timestamp, type, message);

      // make a copy of the listener list in case
      // anyone adds/removes listeners
      Vector targets;
      synchronized (this) {
        targets = (Vector) listeners.clone();
      }

      // walk through the listener list and
      // call the sunMoved method in each
      Enumeration e = targets.elements();
      while (e.hasMoreElements()) {
        ClusterEventListener l = (ClusterEventListener) e.nextElement();
        l.changeCluster(event);

      }
    }
  }

  @Override
  public String getPurposeString() {
    return "Generates a random radial basis function stream.";
  }

  public String getParameterString() {
    return "";
  }

}