package org.netevolved.analyzer;

import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.entermediadb.asset.MediaArchive;
import org.netevolved.analyzer.bayes.Classification;
import org.netevolved.analyzer.bayes.Classifier;
import org.openedit.Data;
import org.openedit.ModuleManager;
import org.openedit.WebPageRequest;
import org.openedit.cache.CacheManager;
import org.openedit.data.SearcherManager;
import org.openedit.page.manage.PageManager;

public class ClassificationManager {
	
	private static final Log log = LogFactory.getLog(ClassificationManager.class);
	
	private static final Object runOnceObject = new Object();
	private boolean hasRun = false;
	
	protected String fieldCatalogId;
	protected PageManager fieldPageManager;
	protected ModuleManager fieldModuleManager;
	protected SearcherManager fieldSearcherManager;
	protected CacheManager fieldCacheManager;
	

	public PageManager getPageManager() {
		return fieldPageManager;
	}

	public void setPageManager(PageManager inPageManager) {
		fieldPageManager = inPageManager;
	}
	
	
	public ModuleManager getModuleManager() {
		return fieldModuleManager;
	}

	public void setModuleManager(ModuleManager inModuleManager) {
		fieldModuleManager = inModuleManager;
	}

	public SearcherManager getSearcherManager() {
		return fieldSearcherManager;
	}

	public void setSearcherManager(SearcherManager searcherManager) {
		fieldSearcherManager = searcherManager;
	}
	
	public String getCatalogId() {
		return fieldCatalogId;
	}

	public void setCatalogId(String inCatalogId) {
		fieldCatalogId = inCatalogId;
	}

	public CacheManager getCacheManager() {
		return fieldCacheManager;
	}

	public void setCacheManager(CacheManager inCacheManager) {
		fieldCacheManager = inCacheManager;
	}
	
	/**
	 * this method can only be run once for this instance
	 * @param req
	 */
	public void runOnce(WebPageRequest req){
		String event = req.findValue("runonce");
		MediaArchive archive = (MediaArchive) req.getPageValue("mediaarchive");
		if (event!=null && !hasRun && archive!=null){
			synchronized(runOnceObject){
				if (!hasRun){
					log.info("runOnce: firing event "+event);
					archive.fireSharedMediaEvent(event);
					hasRun = true;
				}
			}
		}
	}
	
	/**
	 * 
	 * @param inClassifiertype
	 * @param inClassifierId
	 * @param inCategory
	 * @param inData
	 * @param inField
	 */
	public void train(String inClassifiertype, String inClassifierId, String inCategory, Data inData, String inField){
		Classifier<String,String> classifier = getClassifier(inClassifierId, inClassifiertype);
		if(classifier.getPreProcessor() != null && inData.get(inField)!=null && !inData.get(inField).isEmpty()){
			List<String> features = (List<String>) classifier.getPreProcessor().getFeatures(getCatalogId(),inData.get(inField));
			classifier.learn(inCategory, features);
		}
	}
	
	/**
	 * 
	 * @param inClassifiertype
	 * @param inClassifierId
	 * @param inCategory
	 * @param inEntry
	 */
	public void train(String inClassifiertype, String inClassifierId, String inCategory, String inEntry){
		Classifier<String,String> classifier = getClassifier(inClassifierId, inClassifiertype);
		if(classifier.getPreProcessor() != null && inEntry!=null && !inEntry.isEmpty()){
			List<String> features = (List<String>) classifier.getPreProcessor().getFeatures(getCatalogId(),inEntry);
			classifier.learn(inCategory, features);
		}
	}
	
	/**
	 * 
	 * @param inClassifiertype
	 * @param inClassifierId
	 * @param inData
	 * @param inField
	 * @return
	 */
	public Classification<String, String> classify(String inClassifiertype, String inClassifierId, Data inData, String inField){
		Classifier<String, String> classifier = getClassifier(inClassifierId, inClassifiertype);
		if(classifier.getPreProcessor() != null && inData.get(inField)!=null && !inData.get(inField).isEmpty()){
			List<String> features = (List<String>) classifier.getPreProcessor().getFeatures(getCatalogId(),inData.get(inField));
			return classifier.classify(features);
		}
		return null;
	}
	
	/**
	 * 
	 * @param inClassifiertype
	 * @param inClassifierId
	 * @param inEntry
	 * @return
	 */
	public Classification<String, String> classify(String inClassifiertype, String inClassifierId, String inEntry){
		Classifier<String, String> classifier = getClassifier(inClassifierId, inClassifiertype);
		if(classifier.getPreProcessor() != null && inEntry!=null && !inEntry.isEmpty()){
			List<String> features = (List<String>) classifier.getPreProcessor().getFeatures(getCatalogId(),inEntry);
			return classifier.classify(features);
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	protected Classifier<String, String> getClassifier(String inClassifierId,
			String inClassifiertype) {
		Classifier<String, String> target = (Classifier<String, String>) getCacheManager().get(getCatalogId() + "classifier", inClassifierId);
		if(target == null){
			target = (Classifier<String, String>) getModuleManager().getBean(getCatalogId(), inClassifiertype + "Classifier");
			getCacheManager().put(getCatalogId() + "classifier", inClassifierId, target);
		}
		return target;
	}
	
	/**
	 * resets classifier to default state
	 * @param inClassifierId
	 * @param inClassifiertype
	 * @return
	 */
	public Classifier<String,String> resetClassifier(String inClassifierId,
			String inClassifiertype){
		if (isTrained(inClassifierId,inClassifiertype)){
			getCacheManager().remove(getCatalogId() + "classifier", inClassifierId);
		}
		return getClassifier(inClassifierId,inClassifiertype);
	}
	
	/**
	 * checks whether the classifier has been trained
	 * @param inClassifierId
	 * @param inClassifiertype
	 * @return
	 */
	public boolean isTrained(String inClassifierId, String inClassifiertype){
		Classifier<String, String> classifier = getClassifier(inClassifierId,inClassifiertype);
		return classifier.isTrained();
	}
}