package org.apache.samoa.learners.classifiers;

/*
 * #%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.util.HashMap;
import java.util.Map;

import org.apache.samoa.instances.Instance;
import org.apache.samoa.instances.Instances;
import org.apache.samoa.moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
import org.apache.samoa.moa.core.GaussianEstimator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Implementation of a non-distributed Naive Bayes classifier.
 * 
 * At the moment, the implementation models all attributes as numeric attributes.
 * 
 * @author Olivier Van Laere (vanlaere yahoo-inc dot com)
 */
public class NaiveBayes implements LocalLearner {

  /**
   * Default smoothing factor. For now fixed to 1E-20.
   */
  private static final double ADDITIVE_SMOOTHING_FACTOR = 1e-20;

  /**
   * serialVersionUID for serialization
   */
  private static final long serialVersionUID = 1325775209672996822L;

  /**
   * Instance of a logger for use in this class.
   */
  private static final Logger logger = LoggerFactory.getLogger(NaiveBayes.class);

  /**
   * The actual model.
   */
  protected Map<Integer, GaussianNumericAttributeClassObserver> attributeObservers;

  /**
   * Class statistics
   */
  protected Map<Integer, Double> classInstances;

  /**
   * Class zero-prototypes.
   */
  protected Map<Integer, Double> classPrototypes;

  /**
   * Retrieve the number of classes currently known to this local model
   * 
   * @return the number of classes currently known to this local model
   */
  protected int getNumberOfClasses() {
    return this.classInstances.size();
  }

  /**
   * Track training instances seen.
   */
  protected long instancesSeen = 0L;

  /**
   * Explicit no-arg constructor.
   */
  public NaiveBayes() {
    // Init the model
    resetLearning();
  }

  /**
   * Create an instance of this LocalLearner implementation.
   */
  @Override
  public LocalLearner create() {
    return new NaiveBayes();
  }

  /**
   * Predicts the class memberships for a given instance. If an instance is unclassified, the returned array elements
   * will be all zero.
   * 
   * Smoothing is being implemented by the AttributeClassObserver classes. At the moment, the
   * GaussianNumericProbabilityAttributeClassObserver needs no smoothing as it processes continuous variables.
   * 
   * Please note that we transform the scores to log space to avoid underflow, and we replace the multiplication with
   * addition.
   * 
   * The resulting scores are no longer probabilities, as a mixture of probability densities and probabilities can be
   * used in the computation.
   * 
   * @param inst
   *          the instance to be classified
   * @return an array containing the estimated membership scores of the test instance in each class, in log space.
   */
  @Override
  public double[] getVotesForInstance(Instance inst) {
    // Prepare the results array
    double[] votes = new double[getNumberOfClasses()];
    // Over all classes
    for (int classIndex = 0; classIndex < votes.length; classIndex++) {
      // Get the prior for this class
      votes[classIndex] = Math.log(getPrior(classIndex));
      // Iterate over the instance attributes
      for (int index = 0; index < inst.numAttributes(); index++) {
        int attributeID = inst.index(index);
        // Skip class attribute
        if (attributeID == inst.classIndex())
          continue;
        Double value = inst.value(attributeID);
        // Get the observer for the given attribute
        GaussianNumericAttributeClassObserver obs = attributeObservers.get(attributeID);
        // Init the estimator to null by default
        GaussianEstimator estimator = null;
        if (obs != null && obs.getEstimator(classIndex) != null) {
          // Get the estimator
          estimator = obs.getEstimator(classIndex);
        }
        double valueNonZero;
        // The null case should be handled by smoothing!
        if (estimator != null) {
          // Get the score for a NON-ZERO attribute value
          valueNonZero = estimator.probabilityDensity(value);
        }
        // We don't have an estimator
        else {
          // Assign a very small probability that we do see this value
          valueNonZero = ADDITIVE_SMOOTHING_FACTOR;
        }
        votes[classIndex] += Math.log(valueNonZero); // - Math.log(valueZero);
      }
      // Check for null in the case of prequential evaluation
      if (this.classPrototypes.get(classIndex) != null) {
        // Add the prototype for the class, already in log space
        votes[classIndex] += Math.log(this.classPrototypes.get(classIndex));
      }
    }
    return votes;
  }

  /**
   * Compute the prior for the given classIndex.
   * 
   * Implemented by maximum likelihood at the moment.
   * 
   * @param classIndex
   *          Id of the class for which we want to compute the prior.
   * @return Prior probability for the requested class
   */
  private double getPrior(int classIndex) {
    // Maximum likelihood
    Double currentCount = this.classInstances.get(classIndex);
    if (currentCount == null || currentCount == 0)
      return 0;
    else
      return currentCount * 1. / this.instancesSeen;
  }

  /**
   * Resets this classifier. It must be similar to starting a new classifier from scratch.
   */
  @Override
  public void resetLearning() {
    // Reset priors
    this.instancesSeen = 0L;
    this.classInstances = new HashMap<>();
    this.classPrototypes = new HashMap<>();
    // Init the attribute observers
    this.attributeObservers = new HashMap<>();
  }

  /**
   * Trains this classifier incrementally using the given instance.
   * 
   * @param inst
   *          the instance to be used for training
   */
  @Override
  public void trainOnInstance(Instance inst) {
    // Update class statistics with weights
    int classIndex = (int) inst.classValue();
    Double weight = this.classInstances.get(classIndex);
    if (weight == null)
      weight = 0.;
    this.classInstances.put(classIndex, weight + inst.weight());

    // Get the class prototype
    Double classPrototype = this.classPrototypes.get(classIndex);
    if (classPrototype == null)
      classPrototype = 1.;

    // Iterate over the attributes of the given instance
    for (int attributePosition = 0; attributePosition < inst
        .numAttributes(); attributePosition++) {
      // Get the attribute index - Dense -> 1:1, Sparse is remapped
      int attributeID = inst.index(attributePosition);
      // Skip class attribute
      if (attributeID == inst.classIndex())
        continue;
      // Get the attribute observer for the current attribute
      GaussianNumericAttributeClassObserver obs = this.attributeObservers
          .get(attributeID);
      // Lazy init of observers, if null, instantiate a new one
      if (obs == null) {
        // FIXME: At this point, we model everything as a numeric
        // attribute
        obs = new GaussianNumericAttributeClassObserver();
        this.attributeObservers.put(attributeID, obs);
      }

      // Get the probability density function under the current model
      GaussianEstimator obs_estimator = obs.getEstimator(classIndex);
      if (obs_estimator != null) {
        // Fetch the probability that the feature value is zero
        double probDens_zero_current = obs_estimator.probabilityDensity(0);
        classPrototype -= probDens_zero_current;
      }

      // FIXME: Sanity check on data values, for now just learn
      // Learn attribute value for given class
      obs.observeAttributeClass(inst.valueSparse(attributePosition),
          (int) inst.classValue(), inst.weight());

      // Update obs_estimator to fetch the pdf from the updated model
      obs_estimator = obs.getEstimator(classIndex);
      // Fetch the probability that the feature value is zero
      double probDens_zero_updated = obs_estimator.probabilityDensity(0);
      // Update the class prototype
      classPrototype += probDens_zero_updated;
    }
    // Store the class prototype
    this.classPrototypes.put(classIndex, classPrototype);
    // Count another training instance
    this.instancesSeen++;
  }

  @Override
  public void setDataset(Instances dataset) {
    // Do nothing
  }
}