org.eclipse.osbp.xtext.reportdsl/src/org/eclipse/osbp/xtext/reportdsl/common/item/DataUtils.java

package org.eclipse.osbp.xtext.reportdsl.common.item;

import org.eclipse.birt.report.model.api.DesignElementHandle;
import org.eclipse.birt.report.model.api.Expression;
import org.eclipse.birt.report.model.api.ExpressionType;
import org.eclipse.birt.report.model.api.HideRuleHandle;
import org.eclipse.birt.report.model.api.StructureFactory;
import org.eclipse.birt.report.model.api.activity.SemanticException;
import org.eclipse.birt.report.model.api.elements.DesignChoiceConstants;
import org.eclipse.birt.report.model.api.elements.structures.AggregationArgument;
import org.eclipse.birt.report.model.api.elements.structures.ComputedColumn;
import org.eclipse.birt.report.model.api.elements.structures.HideRule;
import org.eclipse.birt.report.model.elements.interfaces.IReportItemModel;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.osbp.dsl.semantic.entity.LEntityAttribute;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAttribute;
import org.eclipse.osbp.xtext.datamartdsl.util.DatamartAttributeUtil;
import org.eclipse.osbp.xtext.reportdsl.DatamartTableAttribute;
import org.eclipse.osbp.xtext.reportdsl.DatamartTableGroup;
import org.eclipse.osbp.xtext.reportdsl.PageBreak;
import org.eclipse.osbp.xtext.reportdsl.PureAggregationTypeEnum;
import org.eclipse.osbp.xtext.reportdsl.TableAggregation;
import org.eclipse.osbp.xtext.reportdsl.TableAttribute;
import org.eclipse.osbp.xtext.reportdsl.TableBaseAggregation;
import org.eclipse.osbp.xtext.reportdsl.TableBinaryAggregation;
import org.eclipse.osbp.xtext.reportdsl.TableMultipleAggregation;
import org.eclipse.osbp.xtext.reportdsl.TablePureAggregation;
import org.eclipse.osbp.xtext.reportdsl.TableUnaryAggregation;
import org.eclipse.osbp.xtext.reportdsl.TableValueElement;
import org.eclipse.osbp.xtext.reportdsl.common.DataTypes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DataUtils {
	private static final Logger LOGGER = LoggerFactory.getLogger(DataUtils.class);
	public static final String DISPLAYNAME_AGGREGATION_PREFIX = "AGGREGATION_";
	
	public static String getAttributeName(DatamartTableAttribute tableAttribute) {
		TableValueElement element = tableAttribute.getColumn();
		return getResultSetColumn(element);
	}
	
	public static String getResultSetColumn(TableValueElement element) {
		if	(element instanceof TableAggregation) {
			TableBaseAggregation aggregation = ((TableAggregation) element).getAggregation();
			String groupOn = getGroupOn(element);
			String function = getAggregateFunctionName(element);
			String resultSetColumn = (groupOn == null ? "" : groupOn+"_")+function;
			for	(DatamartAttribute valueRef : aggregation.getValueRefs()) {
				// TODO (JCD): Change to aliasName? DatamartAttributeUtil.getAliasedAttributeName(valueRef)?
				resultSetColumn += "_"+valueRef.getAttributeRef().getName();
			}
			return resultSetColumn;
		}
		else if	(element instanceof TableAttribute) {
			return DatamartAttributeUtil.getAliasedAttributeName(((TableAttribute) element).getValueRef());
		}
		return null;
	}

	public static Enum<?> getAggregateFunctionEnum(TableValueElement element) {
		if	(element instanceof TableAggregation) {
			TableBaseAggregation aggregation = ((TableAggregation) element).getAggregation();
			if	(aggregation instanceof TablePureAggregation) {
				return ((TablePureAggregation)aggregation).getAggregation();
			}
			else if	(aggregation instanceof TableUnaryAggregation) {
				return ((TableUnaryAggregation)aggregation).getAggregation();
			}
			else if (aggregation instanceof TableBinaryAggregation) {
				return ((TableBinaryAggregation)aggregation).getAggregation();
			}
			else if (aggregation instanceof TableMultipleAggregation) {
				return ((TableMultipleAggregation)aggregation).getAggregation();
			}
		}
		return null;
	}

	public static String getAggregateFunctionName(TableValueElement element) {
		if	(element instanceof TableAggregation) {
			TableBaseAggregation aggregation = ((TableAggregation) element).getAggregation();
			if	(aggregation instanceof TablePureAggregation) {
				return ((TablePureAggregation)aggregation).getAggregation().getName();
			}
			else if	(aggregation instanceof TableUnaryAggregation) {
				return ((TableUnaryAggregation)aggregation).getAggregation().getName();
			}
			else if (aggregation instanceof TableBinaryAggregation) {
				return ((TableBinaryAggregation)aggregation).getAggregation().getName();
			}
			else if (aggregation instanceof TableMultipleAggregation) {
				return ((TableMultipleAggregation)aggregation).getAggregation().getName();
			}
		}
		return null;
	}

	public static String getGroupOn(TableValueElement element) {
		if	(element instanceof TableAggregation) {
			if	(((TableAggregation)element).getOnGroup() == null) {
				EObject container = element;
				while	(container.eContainer() != null) {
					container = container.eContainer();
					if	(container instanceof DatamartTableGroup) {
						return ((DatamartTableGroup) container).getName();
					}
				}
			}
			else {
				return ((TableAggregation)element).getOnGroup().getName();
			}
		}
		return null;
	}

	public static ComputedColumn createComputedColumn(TableAggregation aggregation) {
		EList<DatamartAttribute> valueRefs = aggregation.getAggregation().getValueRefs();
		Enum<?> function = DataUtils.getAggregateFunctionEnum(aggregation);
		DataTypes dataType = DataTypes.STRING;
		String prefix = "";
		if	(!valueRefs.isEmpty()) {
			DatamartAttribute reference = valueRefs.get(0);
			// --- general information about the column ---
			if	(reference != null) {
				LEntityAttribute attribute = reference.getAttributeRef();
				dataType = DataTypes.typeFor(attribute.getType());
			}
		}
		else if	(function.equals(PureAggregationTypeEnum.COUNT) || 
				function.equals(PureAggregationTypeEnum.RUNNINGCOUNT)) {
			dataType = DataTypes.INTEGER;
			prefix = DISPLAYNAME_AGGREGATION_PREFIX;
		}
		String name = DataUtils.getResultSetColumn(aggregation);
		String displayName = name;
		if	(aggregation.getText() != null) {
			displayName = aggregation.getText().replaceAll("\"", "");
		}
		// --- information needed to access via table ---
		ComputedColumn aggregationColumn = StructureFactory.createComputedColumn();
		aggregationColumn.setName(name);
		aggregationColumn.setDisplayName(prefix+displayName);
		aggregationColumn.setDataType(dataType.getNativeOdaDataTypeName());
		String groupOn = DataUtils.getGroupOn(aggregation);
		if	(groupOn != null) {
			aggregationColumn.setAggregateOn(groupOn);
		}
		aggregationColumn.setAggregateFunction(DataUtils.getAggregateFunctionName(aggregation));
		for	(DatamartAttribute property : valueRefs) {
			AggregationArgument argument = StructureFactory.createAggregationArgument();
			argument.setName("Expression");
			Expression expression = new Expression("dataSetRow[\"" + DatamartAttributeUtil.getAliasedAttributeName(property) + "\"]", ExpressionType.JAVASCRIPT);
			argument.setExpressionProperty("value", expression);
			aggregationColumn.addArgument(argument);
		}
		aggregationColumn.setAllowExport(true);
		return aggregationColumn;
	}
	
	public static void addVisibility(DesignElementHandle handle, DatamartAttribute property) throws SemanticException {
		HideRule hideRule = StructureFactory.createHideRule();
		hideRule.setFormat( DesignChoiceConstants.FORMAT_TYPE_ALL );
		HideRuleHandle hideHandle = (HideRuleHandle) handle.getPropertyHandle(IReportItemModel.VISIBILITY_PROP).addItem(hideRule);
		Expression expression = new Expression("row[\"" + DatamartAttributeUtil.getAliasedAttributeName(property) + "\"]==false", ExpressionType.JAVASCRIPT);
		hideHandle.setExpressionProperty(HideRule.VALUE_EXPR_MEMBER, expression);
	}
	
}