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

/**
 *                                                                            
 * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 *                                                                            
 * All rights reserved. This program and the accompanying materials           
 * are made available under the terms of the Eclipse Public License v1.0       
 * which accompanies this distribution, and is available at                  
 * http://www.eclipse.org/legal/epl-v10.html                                 
 *                                                                            
 * Contributors:   
 * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation 
 */
package org.eclipse.osbp.xtext.reportdsl.common.item;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.birt.report.model.api.OdaDataSetHandle;
import org.eclipse.birt.report.model.api.ReportItemHandle;
import org.eclipse.birt.report.model.api.StructureFactory;
import org.eclipse.birt.report.model.api.TextItemHandle;
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.ComputedColumn;
import org.eclipse.birt.report.model.elements.interfaces.IReportItemModel;
import org.eclipse.osbp.dsl.semantic.common.types.LDataType;
import org.eclipse.osbp.dsl.semantic.common.types.LDateType;
import org.eclipse.osbp.dsl.semantic.common.types.LScalarType;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAttribute;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDefinition;
import org.eclipse.osbp.xtext.datamartdsl.util.DatamartAttributeUtil;
import org.eclipse.osbp.xtext.reportdsl.AutoTextEnum;
import org.eclipse.osbp.xtext.reportdsl.DatamartTableAttribute;
import org.eclipse.osbp.xtext.reportdsl.StringBinder;
import org.eclipse.osbp.xtext.reportdsl.StringBinderValue;
import org.eclipse.osbp.xtext.reportdsl.NonTranslatableText;
import org.eclipse.osbp.xtext.reportdsl.TranslatableText;
import org.eclipse.osbp.xtext.reportdsl.TableAggregation;
import org.eclipse.osbp.xtext.reportdsl.TableAttribute;
import org.eclipse.osbp.xtext.reportdsl.jvmmodel.ReportGeneratorWorkSet;
import org.eclipse.osbp.xtext.reportdsl.jvmmodel.Utilities;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TextDataItem implements BaseItem {

	private static final Logger LOGGER = LoggerFactory.getLogger(TextDataItem.class);
	private final TextItemHandle fItem;
	
	public TextDataItem(ReportGeneratorWorkSet workset, String contentType, DatamartDefinition datamart, List<DatamartAttribute> datamartAttributes) {
		fItem = workset.getFactory().newTextItem(null);
		try {
			fItem.setContentType(contentType);
			String alias = null;
			String dataSetName = Utilities.getDataSetName(alias, datamart);
			OdaDataSetHandle dataSetHandle = workset.getDataSets().get(dataSetName);
			if (dataSetHandle != null) {
				fItem.setDataSet(dataSetHandle);
				setBoundColumns(datamartAttributes);
			}
		} catch (SemanticException e) {
			LOGGER.error("{}", e);
		}
	}
	
	public TextDataItem(ReportGeneratorWorkSet workset, String contentType, DatamartDefinition datamart, StringBinder stringBinder) {
		fItem = workset.getFactory().newTextItem(null);
		try {
			fItem.setContentType(contentType);
			String alias = null;
			String dataSetName = Utilities.getDataSetName(alias, datamart);
			OdaDataSetHandle dataSetHandle = workset.getDataSets().get(dataSetName);
			if (dataSetHandle != null) {
				fItem.setDataSet(dataSetHandle);
				setContent(stringBinder);
			}
		} catch (SemanticException e) {
			LOGGER.error("{}", e);
		}
	}
	
	public TextDataItem(ReportGeneratorWorkSet workset, String contentType, AutoTextEnum autoTextEnum) {
		fItem = workset.getFactory().newTextItem(null);
		try {
			fItem.setContentType(contentType);
			setContent(autoTextEnum);
		} catch (SemanticException e) {
			LOGGER.error("{}", e);
		}
	}
	
	@Override
	public ReportItemHandle getHandle() {
		return fItem;
	}
	
//	private String getContent(ArrayList<ComputedColumn> boundColumns){
//		StringBuilder result = new StringBuilder();
//		for (int columncount = 0; columncount < boundColumns.size(); columncount++) {
//			result.append(getRowContent(boundColumns.get(columncount).getName()));
//			if ((boundColumns.size() > 1) && ((columncount + 1) != boundColumns.size())) {
//				result.append(" + \" \" + ");
//			} 
//		}
//		return getValueOfContent(result.toString());
//	}
//	
	private String getContent(ArrayList<Object> elements){
		StringBuilder result = new StringBuilder();
		for (int elementsCount = 0; elementsCount < elements.size(); elementsCount++) {
			Object element = elements.get(elementsCount);
			String elementValue = "";
			if (element instanceof ComputedColumn){
				String dataType = ((ComputedColumn) element).getDataType();
				if (DesignChoiceConstants.COLUMN_DATA_TYPE_DATE.equals(dataType) || DesignChoiceConstants.COLUMN_DATA_TYPE_TIME.equals(dataType) || DesignChoiceConstants.COLUMN_DATA_TYPE_DATETIME.equals(dataType)){
					elementValue = getDateTimeRowContent(((ComputedColumn) element).getName());
				} else {
					elementValue = getRowContent(((ComputedColumn) element).getName());
				}
			} else if (element instanceof TranslatableText) {
				elementValue = "reportContext.getMessage(\"" + (((TranslatableText)element).getValue()) + "\",reportContext.getLocale())";
			} else if (element instanceof NonTranslatableText) {
				elementValue = "\"" + (((NonTranslatableText)element).getValue()) + "\"";
			}
			result.append(elementValue);
			if ((elements.size() > 1) && ((elementsCount + 1) != elements.size())) {
				result.append(" + \" \" + ");
			} 
		}
		return getValueOfContent(result.toString());
	}
	
	private String getRowContent(String rowContent){
		return "row[\"" + rowContent + "\"]";
	}
	
	private String getDateTimeRowContent(String rowContent){
		return "java.text.DateFormat.getDateInstance(java.text.DateFormat.SHORT,reportContext.getLocale()).format(row[\"" + rowContent + "\"])";
	}
	
	private String getValueOfContent(String content){
		return "<VALUE-OF>" + content + "</VALUE-OF>";
	}
	
	private void setBoundColumns(List<DatamartAttribute> datamartAttributes) {	// NOSONAR
		ArrayList<Object> boundColumns = new ArrayList<>();
		for	(DatamartAttribute datamartAttribute : datamartAttributes) {
			boundColumns.add(createComputedColumn(datamartAttribute));
		}
		// --- set all bound elements ---
		fItem.getElement().setProperty(IReportItemModel.BOUND_DATA_COLUMNS_PROP, boundColumns);
		try {
			fItem.setContent(getContent(boundColumns));
		} catch (SemanticException e) {
			LOGGER.error("{}", e);
		}
	}

	private void setContent(StringBinder stringBinder) throws SemanticException {	// NOSONAR
		ArrayList<Object> contentElements = new ArrayList<>();
		for	(StringBinderValue stringBinderValue : stringBinder.getElements()) {
			if (stringBinderValue instanceof TableAttribute) {
				ComputedColumn computedColumn = createComputedColumn(((TableAttribute)stringBinderValue).getValueRef());
				contentElements.add(computedColumn);
			} else if (stringBinderValue instanceof StringBinderValue){
				contentElements.add(stringBinderValue);
			}
		}
		fItem.setContent(getContent(contentElements));
	}
	
	private void setContent(AutoTextEnum autoTextEnum) throws SemanticException {	// NOSONAR
		String content;
		switch (autoTextEnum) {
		case ACTUAL_DATE:
			content = "java.text.DateFormat.getDateInstance(3).format(new Date())";
			fItem.setContent(getValueOfContent(content));
			break;
		case ACTUAL_TIME:
			content = "java.text.DateFormat.getTimeInstance(3).format(new Date())";
			fItem.setContent(getValueOfContent(content));
			break;
		default:
			break;
		} 
	}
	
	private ComputedColumn createComputedColumn(DatamartAttribute datamartAttribute) {
		String attributeName = DatamartAttributeUtil.getAliasedAttributeName(datamartAttribute);
		ComputedColumn column = StructureFactory.createComputedColumn();
		column.setName(attributeName);
		column.setDisplayName(attributeName);
		LScalarType type = datamartAttribute.getAttributeRef().getType();
		if (type instanceof LDataType){
			String typeName = "";
			LDataType dType = (LDataType) type;
			if (dType.isDate()){
				if (dType.getDateType() == LDateType.DATE) {
					typeName = DesignChoiceConstants.COLUMN_DATA_TYPE_DATE;
				} else if (dType.getDateType() == LDateType.TIME) {
						typeName = DesignChoiceConstants.COLUMN_DATA_TYPE_TIME;
				} else if (dType.getDateType() == LDateType.TIMESTAMP) {
					typeName = DesignChoiceConstants.COLUMN_DATA_TYPE_DATETIME;
				}
			} else {
				typeName = dType.getJvmTypeReference().getSimpleName();
			}
			column.setDataType(typeName);
			column.setExpression("dataSetRow[\"".concat(attributeName).concat("\"]"));
		}
		return column;
	}

}