package org.netevolved.reporting;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.entermediadb.asset.MediaArchive;
import org.openedit.Data;
import org.openedit.hittracker.HitTracker;
import org.openedit.money.Money;

public abstract class BaseReportGroup implements ReportGroup{
	
	protected String fieldLabel;
	protected HitTracker fieldHitTracker;
	protected Map<String,Money> fieldMoneyMap;// various tallies of money
	protected Map<String,Float> fieldFloatMap;// various tallies of float values
	protected Map<String,Map<String,Integer>> fieldCountUniqueMap;// count unique entries
	protected int fieldCount;// total # of occurrences
	protected MediaArchive fieldMediaArchive;
	
	public MediaArchive getMediaArchive() {
		return fieldMediaArchive;
	}

	public void setMediaArchive(MediaArchive inMediaArchive) {
		fieldMediaArchive = inMediaArchive;
	}

	public Map<String,Map<String,Integer>> getCountUniqueMap() {
		if (fieldCountUniqueMap == null){
			fieldCountUniqueMap = new HashMap<String,Map<String,Integer>>();
		}
		return fieldCountUniqueMap;
	}

	public void setCountUniqueMap(Map<String,Map<String,Integer>> inCountUniqueMap) {
		fieldCountUniqueMap = inCountUniqueMap;
	}
	
	public Object load(Data inData) {
		return getHitTracker().getSearcher().searchById(inData.getId());
	}

	public Map<String, Money> getMoneyMap() {
		if (fieldMoneyMap == null){
			fieldMoneyMap = new HashMap<String,Money>();
		}
		return fieldMoneyMap;
	}

	public void setMoneyMap(Map<String, Money> inMoneyMap) {
		fieldMoneyMap = inMoneyMap;
	}

	public Map<String, Float> getFloatMap() {
		if (fieldFloatMap == null){
			fieldFloatMap = new HashMap<String,Float>();
		}
		return fieldFloatMap;
	}

	public void setFloatMap(Map<String, Float> inFloatMap) {
		fieldFloatMap = inFloatMap;
	}

	public int getCount() {
		return fieldCount;
	}

	public void setCount(int inCount) {
		fieldCount = inCount;
	}

	public String getLabel() {
		return fieldLabel;
	}

	public void setLabel(String inLabel) {
		fieldLabel = inLabel;
	}

	public HitTracker getHitTracker() {
		return fieldHitTracker;
	}

	public void setHitTracker(HitTracker inHitsTracker) {
		fieldHitTracker = inHitsTracker;
		setCount(fieldHitTracker.size());
	}
	
	public void addMoney(String inKey, Money inValue){
		if (inKey!=null && inValue!=null){
			Money current = new Money(0);
			if (getMoneyMap().containsKey(inKey)){
				current = getMoneyMap().get(inKey);
			}
			current = current.add(inValue);
			getMoneyMap().put(inKey,current);
		}
	}
	
	public void addMoneyAsString(String inKey, String inValue){
		if (inKey!=null && inValue!=null){
			Money current = new Money(0);
			if (getMoneyMap().containsKey(inKey)){
				current = getMoneyMap().get(inKey);
			}
			current = current.add(new Money(inValue));
			getMoneyMap().put(inKey,current);
		}
	}
	
	public Money getMoney(String inValue){
		Money money = new Money(getDouble(inValue,0));
		return money;
	}
	
	public Money getMoney(String inKey, String inDefault){
		Money money = new Money(inDefault);
		if (inKey!=null && getMoneyMap().containsKey(inKey)){
			return getMoneyMap().get(inKey);
		}
		return money;
	}
	
	public void addFloat(String inKey, Float inValue){
		if (inKey!=null && inValue!=null){
			float current = 0;
			if (getFloatMap().containsKey(inKey)){
				current = getFloatMap().get(inKey).floatValue();
			}
			current = current + inValue.floatValue();
			getFloatMap().put(inKey,new Float(current));
		}
	}
	
	public void addFloatAsString(String inKey, String inValue){
		if (inKey!=null && inValue!=null){
			Float f = Float.parseFloat(inValue);
			addFloat(inKey,f);
		}
	}
	
	public Float getFloat(String inKey, String inDefault){
		Float f = Float.parseFloat(inDefault);
		if (inKey!=null && getFloatMap().containsKey(inKey)){
			return getFloatMap().get(inKey);
		}
		return f;
	}
	
	public void incrementUniqueCount(String inKey, String inId){
		Map<String,Integer> map = new HashMap<String,Integer>();
		if (getCountUniqueMap().containsKey(inKey)){
			map = getCountUniqueMap().get(inKey);
		} else {
			getCountUniqueMap().put(inKey,map);
		}
		int count = 0;
		if (map.containsKey(inId)){
			count = map.get(inId).intValue();
		}
		count ++;
		map.put(inId,new Integer(count));
	}
	
	public Integer getUniqueCount(String inKey, String inId){
		if (getCountUniqueMap().containsKey(inKey)){
			Map<String,Integer> map = getCountUniqueMap().get(inKey);
			if (map.containsKey(inId)){
				return map.get(inId);
			}
		}
		return new Integer(0);
	}
	
	public Set<String> getUniqueCountIds(String inKey){
		if (getCountUniqueMap().containsKey(inKey)){
			return getCountUniqueMap().get(inKey).keySet();
		}
		return new HashSet<String>();
	}
	
	public int sumAllUniqueOccurrences(String inKey){
		int sum = getCountUniqueMap().containsKey(inKey) ?  getCountUniqueMap().get(inKey).keySet().size() : 0;
		return sum;
	}
	
	public Object loadObjectByField(String inSearcher, String inField, String inValue){
		if (inSearcher!=null && inField!=null && inValue!=null){
			return getMediaArchive().getSearcher(inSearcher).searchByField(inField, inValue);
		}
		return null;
	}
	
	public Object getDisplayValue(String inSearcher, String inField, String inValue, String inDisplay, Object inDefault){
		if (inSearcher!=null && inField!=null && inValue!=null){
			Data data = (Data) getMediaArchive().getSearcher(inSearcher).searchByField(inField, inValue);
			if (data != null && data.get(inDisplay)!=null){
				return data.get(inDisplay);
			}
		}
		return inDefault;
	}
	
	public double getDouble(String inValue, double inDefault){
		try{
			return Double.parseDouble(inValue.replace(",","").replace("$",""));
		}catch (Exception e){}
		return inDefault;
	}
}