/**
 * 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
 * 
 * 
 *  This copyright notice shows up in the generated Java code
 */
package org.eclipse.osbp.xtext.reportdsl.jvmmodel;

import com.google.common.base.Objects;
import com.google.inject.Inject;
import com.ibm.icu.util.ULocale;
import com.vaadin.data.Container;
import com.vaadin.server.Sizeable;
import com.vaadin.server.StreamResource;
import com.vaadin.ui.AbstractComponent;
import com.vaadin.ui.BrowserFrame;
import com.vaadin.ui.Button;
import com.vaadin.ui.HorizontalLayout;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.UUID;
import java.util.function.BiConsumer;
import org.eclipse.birt.report.model.api.ColumnHandle;
import org.eclipse.birt.report.model.api.DesignElementHandle;
import org.eclipse.birt.report.model.api.DimensionHandle;
import org.eclipse.birt.report.model.api.GridHandle;
import org.eclipse.birt.report.model.api.IDesignEngine;
import org.eclipse.birt.report.model.api.OdaDataSetHandle;
import org.eclipse.birt.report.model.api.OdaDataSourceHandle;
import org.eclipse.birt.report.model.api.ReportItemHandle;
import org.eclipse.birt.report.model.api.RowHandle;
import org.eclipse.birt.report.model.api.SessionHandle;
import org.eclipse.birt.report.model.api.SimpleMasterPageHandle;
import org.eclipse.birt.report.model.api.StructureFactory;
import org.eclipse.birt.report.model.api.command.ContentException;
import org.eclipse.birt.report.model.api.command.CustomMsgException;
import org.eclipse.birt.report.model.api.core.IModuleModel;
import org.eclipse.birt.report.model.api.elements.DesignChoiceConstants;
import org.eclipse.birt.report.model.api.elements.structures.CachedMetaData;
import org.eclipse.birt.report.model.api.elements.structures.ComputedColumn;
import org.eclipse.birt.report.model.api.elements.structures.OdaResultSetColumn;
import org.eclipse.birt.report.model.api.metadata.DimensionValue;
import org.eclipse.birt.report.model.core.ContainerSlot;
import org.eclipse.birt.report.model.core.DesignElement;
import org.eclipse.birt.report.model.elements.interfaces.IDataSetModel;
import org.eclipse.birt.report.model.util.CssPropertyConstants;
import org.eclipse.e4.core.di.extensions.EventUtils;
import org.eclipse.e4.core.services.events.IEventBroker;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.osbp.dsl.semantic.common.types.LDataType;
import org.eclipse.osbp.dsl.semantic.common.types.LKeyAndValue;
import org.eclipse.osbp.dsl.semantic.common.types.LPackage;
import org.eclipse.osbp.dsl.semantic.entity.LEntityAttribute;
import org.eclipse.osbp.eventbroker.EventBrokerMsg;
import org.eclipse.osbp.ui.api.datamart.IDataMart;
import org.eclipse.osbp.ui.api.report.IReportProvider;
import org.eclipse.osbp.utils.entityhelper.DataType;
import org.eclipse.osbp.utils.vaadin.ViewLayoutManager;
import org.eclipse.osbp.xtext.action.common.IToolbarAction;
import org.eclipse.osbp.xtext.basic.generator.BasicDslGeneratorUtils;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAttribute;
import org.eclipse.osbp.xtext.datamartdsl.DatamartCube;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDefinition;
import org.eclipse.osbp.xtext.datamartdsl.DatamartEntity;
import org.eclipse.osbp.xtext.datamartdsl.DatamartNavigation;
import org.eclipse.osbp.xtext.datamartdsl.DatamartRole;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSource;
import org.eclipse.osbp.xtext.datamartdsl.DatamartTask;
import org.eclipse.osbp.xtext.datamartdsl.jvmmodel.DatamartDSLJvmModelInferrer;
import org.eclipse.osbp.xtext.datamartdsl.util.DatamartAttributeUtil;
import org.eclipse.osbp.xtext.i18n.DSLOutputConfigurationProvider;
import org.eclipse.osbp.xtext.i18n.I18NKeyGenerator;
import org.eclipse.osbp.xtext.i18n.I18NModelGenerator;
import org.eclipse.osbp.xtext.reportdsl.AutoText;
import org.eclipse.osbp.xtext.reportdsl.AutoTextEnum;
import org.eclipse.osbp.xtext.reportdsl.DatamartTable;
import org.eclipse.osbp.xtext.reportdsl.DatamartTableAttribute;
import org.eclipse.osbp.xtext.reportdsl.DatamartTableGroup;
import org.eclipse.osbp.xtext.reportdsl.Element;
import org.eclipse.osbp.xtext.reportdsl.Grid;
import org.eclipse.osbp.xtext.reportdsl.GridCell;
import org.eclipse.osbp.xtext.reportdsl.GridRow;
import org.eclipse.osbp.xtext.reportdsl.Image;
import org.eclipse.osbp.xtext.reportdsl.Label;
import org.eclipse.osbp.xtext.reportdsl.NonTranslatableText;
import org.eclipse.osbp.xtext.reportdsl.PageDetail;
import org.eclipse.osbp.xtext.reportdsl.PageFooter;
import org.eclipse.osbp.xtext.reportdsl.PageHeader;
import org.eclipse.osbp.xtext.reportdsl.PageTemplate;
import org.eclipse.osbp.xtext.reportdsl.Report;
import org.eclipse.osbp.xtext.reportdsl.ReportDesign;
import org.eclipse.osbp.xtext.reportdsl.ReportDesignTemplate;
import org.eclipse.osbp.xtext.reportdsl.ReportModel;
import org.eclipse.osbp.xtext.reportdsl.ReportPackage;
import org.eclipse.osbp.xtext.reportdsl.StringBinder;
import org.eclipse.osbp.xtext.reportdsl.Style;
import org.eclipse.osbp.xtext.reportdsl.SubSubTitle;
import org.eclipse.osbp.xtext.reportdsl.SubTitle;
import org.eclipse.osbp.xtext.reportdsl.TableAttribute;
import org.eclipse.osbp.xtext.reportdsl.TableValueElement;
import org.eclipse.osbp.xtext.reportdsl.Text;
import org.eclipse.osbp.xtext.reportdsl.Title;
import org.eclipse.osbp.xtext.reportdsl.UnitEnum;
import org.eclipse.osbp.xtext.reportdsl.common.BaseReport;
import org.eclipse.osbp.xtext.reportdsl.common.BirtEngine;
import org.eclipse.osbp.xtext.reportdsl.common.DataTypes;
import org.eclipse.osbp.xtext.reportdsl.common.OdaConnProperties;
import org.eclipse.osbp.xtext.reportdsl.common.attribute.Attribute;
import org.eclipse.osbp.xtext.reportdsl.common.attribute.Width;
import org.eclipse.osbp.xtext.reportdsl.common.item.BaseItem;
import org.eclipse.osbp.xtext.reportdsl.common.item.BodyItem;
import org.eclipse.osbp.xtext.reportdsl.common.item.ContainerItem;
import org.eclipse.osbp.xtext.reportdsl.common.item.DataUtils;
import org.eclipse.osbp.xtext.reportdsl.common.item.GridItem;
import org.eclipse.osbp.xtext.reportdsl.common.item.ImageItem;
import org.eclipse.osbp.xtext.reportdsl.common.item.PageFooterItem;
import org.eclipse.osbp.xtext.reportdsl.common.item.PageHeaderItem;
import org.eclipse.osbp.xtext.reportdsl.jvmmodel.ReportGeneratorWorkSet;
import org.eclipse.osbp.xtext.reportdsl.jvmmodel.Utilities;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.common.types.JvmDeclaredType;
import org.eclipse.xtext.generator.IFileSystemAccess;
import org.eclipse.xtext.naming.IQualifiedNameProvider;
import org.eclipse.xtext.naming.QualifiedName;
import org.eclipse.xtext.xbase.compiler.GeneratorConfig;
import org.eclipse.xtext.xbase.compiler.ImportManager;
import org.eclipse.xtext.xbase.compiler.output.TreeAppendable;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.Conversions;
import org.eclipse.xtext.xbase.lib.Exceptions;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.IteratorExtensions;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@SuppressWarnings("all")
public class ReportModelGenerator extends I18NModelGenerator {
  @Inject
  @Extension
  private IQualifiedNameProvider _iQualifiedNameProvider;
  
  @Inject
  @Extension
  private DatamartDSLJvmModelInferrer datamartInferrer;
  
  @Inject
  @Extension
  private BasicDslGeneratorUtils _basicDslGeneratorUtils;
  
  @Inject
  @Extension
  private DataType dtType;
  
  private final static Logger LOGGER = LoggerFactory.getLogger(ReportModelGenerator.class);
  
  private static Object designEngine = null;
  
  @Override
  public void doGenerate(final Resource input, final IFileSystemAccess fsa) {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append(BaseReport.CAPTION_I18NKEY_SAVE_PDF);
    _builder.append(",");
    _builder.append(BaseReport.CAPTION_I18NKEY_PRINT_PDF);
    this.addTranslatables(_builder.toString());
    super.doGenerate(input, fsa);
  }
  
  protected void _internalDoGenerate(final ReportModel orgModel, final IFileSystemAccess fsa) {
    ReportModelGenerator.designEngine = BirtEngine.createDesignEngine();
    EList<ReportPackage> _pckg = orgModel.getPckg();
    for (final ReportPackage pkg : _pckg) {
      EList<Report> _reports = pkg.getReports();
      for (final Report report : _reports) {
        try {
          this.generateReportFile(pkg, report, fsa);
        } catch (final Throwable _t) {
          if (_t instanceof Exception) {
            final Exception e = (Exception)_t;
            ReportModelGenerator.LOGGER.error("{}", e);
          } else {
            throw Exceptions.sneakyThrow(_t);
          }
        }
      }
    }
  }
  
  private void generateReportFile(final ReportPackage pckg, final Report report, final IFileSystemAccess fsa) {
    ReportDesign _design = report.getDesign();
    if ((_design instanceof ReportDesignTemplate)) {
      this.generateReportRoleFile(pckg, report, null, fsa);
      EList<DatamartRole> _roles = report.getDatamartRef().getRoles();
      for (final DatamartRole role : _roles) {
        this.generateReportRoleFile(pckg, report, role, fsa);
      }
    }
  }
  
  private void generateReportRoleFile(final ReportPackage pckg, final Report report, final DatamartRole role, final IFileSystemAccess fsa) {
    try {
      ReportGeneratorWorkSet workSet = new ReportGeneratorWorkSet();
      workSet.setGenerator(this);
      workSet.setReport(report);
      workSet.setRole(role);
      workSet.setFsa(fsa);
      ReportDesign _design = report.getDesign();
      ReportDesignTemplate template = ((ReportDesignTemplate) _design);
      String pckgName = this._iQualifiedNameProvider.getFullyQualifiedName(pckg).toString();
      String pckgNamePath = pckgName.replaceAll("\\.", "/");
      StringConcatenation _builder = new StringConcatenation();
      String _name = report.getName();
      _builder.append(_name);
      {
        if ((role != null)) {
          String _name_1 = role.getAssignedRole().getName();
          _builder.append(_name_1);
        }
      }
      _builder.append(".rptdesign");
      String filename = _builder.toString();
      StringConcatenation _builder_1 = new StringConcatenation();
      _builder_1.append(pckgNamePath);
      _builder_1.append("/");
      _builder_1.append(filename);
      String fullpath = _builder_1.toString();
      SessionHandle session = ((IDesignEngine) ReportModelGenerator.designEngine).newSessionHandle(ULocale.forLocale(Locale.getDefault()));
      workSet.setDesign(session.createDesign());
      workSet.setFactory(workSet.getDesign().getElementFactory());
      workSet.getDesign().setIncludeResource("i18n/I18N");
      workSet.getDesign().setProperty(DesignChoiceConstants.CHOICE_UNITS, report.getDefaultUnit().getLiteral());
      workSet.setRequestedMedia(report.getMedia());
      BodyItem body = new BodyItem(workSet);
      this.addDatamartSourceAndSet(report.getDatamartRef(), workSet, null, null);
      this.generateMasterPage(report.getDatamartRef(), workSet, report.getPageTemplate(), template.getHeader(), template.getFooter());
      this.generateItems(report.getDatamartRef(), workSet, body, ((Element[])Conversions.unwrapArray(template.getDetail().getElements(), Element.class)));
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      try {
        workSet.getDesign().getModule().prepareToSave();
        workSet.getDesign().getModule().getWriter().write(baos);
        workSet.getDesign().getModule().onSave();
      } catch (final Throwable _t) {
        if (_t instanceof Exception) {
          final Exception e = (Exception)_t;
          ByteArrayOutputStream _byteArrayOutputStream = new ByteArrayOutputStream();
          baos = _byteArrayOutputStream;
          PrintStream _printStream = new PrintStream(baos);
          e.printStackTrace(_printStream);
        } else {
          throw Exceptions.sneakyThrow(_t);
        }
      }
      fsa.generateFile(fullpath, DSLOutputConfigurationProvider.DEFAULT_REPORT_OUTPUT, baos.toString());
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
  private void generateMasterPage(final DatamartDefinition datamart, final ReportGeneratorWorkSet workSet, final PageTemplate pageTemplate, final PageHeader pageHeader, final PageFooter pageFooter) {
    try {
      PageHeader header = pageHeader;
      PageFooter footer = pageFooter;
      if ((header == null)) {
        header = pageTemplate.getHeader();
      }
      if ((footer == null)) {
        footer = pageTemplate.getFooter();
      }
      SimpleMasterPageHandle masterPage = workSet.getFactory().newSimpleMasterPage(pageTemplate.getName());
      masterPage.setPageType(pageTemplate.getSize().name().toLowerCase());
      masterPage.setOrientation(pageTemplate.getOrientation().name().toLowerCase());
      DimensionHandle _leftMargin = masterPage.getLeftMargin();
      double _leftMarginValue = pageTemplate.getLeftMarginValue();
      String _literal = workSet.getReport().getDefaultUnit().getLiteral();
      DimensionValue _dimensionValue = new DimensionValue(_leftMarginValue, _literal);
      _leftMargin.setValue(_dimensionValue);
      DimensionHandle _topMargin = masterPage.getTopMargin();
      double _topMarginValue = pageTemplate.getTopMarginValue();
      String _literal_1 = workSet.getReport().getDefaultUnit().getLiteral();
      DimensionValue _dimensionValue_1 = new DimensionValue(_topMarginValue, _literal_1);
      _topMargin.setValue(_dimensionValue_1);
      DimensionHandle _bottomMargin = masterPage.getBottomMargin();
      double _bottomMarginValue = pageTemplate.getBottomMarginValue();
      String _literal_2 = workSet.getReport().getDefaultUnit().getLiteral();
      DimensionValue _dimensionValue_2 = new DimensionValue(_bottomMarginValue, _literal_2);
      _bottomMargin.setValue(_dimensionValue_2);
      DimensionHandle _rightMargin = masterPage.getRightMargin();
      double _rightMarginValue = pageTemplate.getRightMarginValue();
      String _literal_3 = workSet.getReport().getDefaultUnit().getLiteral();
      DimensionValue _dimensionValue_3 = new DimensionValue(_rightMarginValue, _literal_3);
      _rightMargin.setValue(_dimensionValue_3);
      if ((header != null)) {
        masterPage.setShowHeaderOnFirst(header.isShowOnFirst());
        DimensionHandle _headerHeight = masterPage.getHeaderHeight();
        double _heightValue = header.getHeightValue();
        String _literal_4 = workSet.getReport().getDefaultUnit().getLiteral();
        DimensionValue _dimensionValue_4 = new DimensionValue(_heightValue, _literal_4);
        _headerHeight.setValue(_dimensionValue_4);
        PageHeaderItem _pageHeaderItem = new PageHeaderItem(workSet, masterPage);
        this.generateItems(datamart, workSet, _pageHeaderItem, ((Element[])Conversions.unwrapArray(header.getElements(), Element.class)));
      }
      if ((footer != null)) {
        masterPage.setShowFooterOnLast(footer.isShowOnLast());
        DimensionHandle _footerHeight = masterPage.getFooterHeight();
        double _heightValue_1 = footer.getHeightValue();
        String _literal_5 = workSet.getReport().getDefaultUnit().getLiteral();
        DimensionValue _dimensionValue_5 = new DimensionValue(_heightValue_1, _literal_5);
        _footerHeight.setValue(_dimensionValue_5);
        PageFooterItem _pageFooterItem = new PageFooterItem(workSet, masterPage);
        this.generateItems(datamart, workSet, _pageFooterItem, ((Element[])Conversions.unwrapArray(footer.getElements(), Element.class)));
      }
      workSet.getDesign().getMasterPages().add(masterPage);
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
  private void addDatamartSourceAndSet(final DatamartDefinition datamart, final ReportGeneratorWorkSet workSet, final String alias, final DatamartAttribute[] hiddens) {
    try {
      String dataSourceName = Utilities.getDataSourceName(alias, datamart).toString();
      ContainerSlot slot = workSet.getDesign().getModule().getSlot(IModuleModel.DATA_SOURCE_SLOT);
      boolean createDataSource = true;
      List<DesignElement> _contents = slot.getContents();
      for (final DesignElement slotElem : _contents) {
        boolean _equals = dataSourceName.equals(slotElem.getName());
        if (_equals) {
          createDataSource = false;
        }
      }
      if (createDataSource) {
        OdaDataSourceHandle odsourceh = workSet.getFactory().newOdaDataSource(dataSourceName, BaseReport.DATASOURCE_EXTENSION_ID);
        odsourceh.getElement().setID(workSet.getDesign().getModule().getNextID());
        workSet.getDesign().getModule().addElementID(odsourceh.getElement());
        workSet.getDesign().getModule().add(odsourceh.getElement(), IModuleModel.DATA_SOURCE_SLOT);
        String dataSetName = Utilities.getDataSetName(alias, datamart).toString();
        OdaDataSetHandle odseth = workSet.getFactory().newOdaDataSet(dataSetName, BaseReport.DATASOURCE_EXTENSION_ID.concat(".dataSet"));
        workSet.getDataSets().put(dataSetName, odseth);
        odseth.getElement().setID(workSet.getDesign().getModule().getNextID());
        odseth.setProperty(OdaConnProperties.DATAMART_BUNDLENAME, Utilities.getBundleName(datamart));
        odseth.setProperty(OdaConnProperties.DATAMART_CLASSNAME, this.getDatamartClassName(alias, datamart));
        odseth.setProperty(OdaConnProperties.DATAMART_DATASOURCE, odsourceh.getElement().getName());
        odseth.setProperty(OdaConnProperties.DATAMART_DATASOURCENAME, dataSourceName);
        odseth.setProperty(OdaConnProperties.DATAMART_DATASETNAME, dataSetName);
        DatamartSource _source = datamart.getSource();
        boolean _matched = false;
        if (_source instanceof DatamartCube) {
          _matched=true;
          this.addDatamartCubeResultSet(workSet, odseth, dataSetName, datamart);
        }
        if (!_matched) {
          if (_source instanceof DatamartEntity) {
            _matched=true;
            this.addDatamartEntityResultSet(workSet, odseth, dataSetName, datamart);
          }
        }
        if (!_matched) {
          if (_source instanceof DatamartTask) {
            _matched=true;
            ReportModelGenerator.LOGGER.error("DatamartTask ... todo");
          }
        }
        workSet.getDesign().getModule().addElementID(odseth.getElement());
        workSet.getDesign().getModule().add(odseth.getElement(), IModuleModel.DATA_SET_SLOT);
      }
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
  private void addDatamartCubeResultSet(final ReportGeneratorWorkSet workSet, final OdaDataSetHandle odseth, final String dataSetName, final DatamartDefinition datamart) {
    try {
      System.err.println("DatamartCube ... todo");
      String selectColumns = "";
      CachedMetaData cmd = new CachedMetaData();
      ArrayList<OdaResultSetColumn> sd = new ArrayList<OdaResultSetColumn>();
      StringConcatenation _builder = new StringConcatenation();
      _builder.append("select ");
      _builder.append(selectColumns);
      _builder.append(" from ");
      String _name = datamart.getName();
      _builder.append(_name);
      odseth.setProperty("queryText", _builder.toString());
      cmd.setProperty(IDataSetModel.RESULT_SET_PROP, sd);
      odseth.setProperty(IDataSetModel.CACHED_METADATA_PROP, cmd);
      odseth.getElement().setProperty(IDataSetModel.RESULT_SET_PROP, sd);
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
  private void addAllDatamartProperties(final ReportGeneratorWorkSet workSet, final ArrayList<OdaResultSetColumn> sd, final ArrayList<ComputedColumn> cc, final EObject eObject) {
    boolean _matched = false;
    if (eObject instanceof DatamartEntity) {
      _matched=true;
      EList<DatamartNavigation> _navigations = ((DatamartEntity)eObject).getNavigations();
      for (final DatamartNavigation navigation : _navigations) {
        final Procedure1<EObject> _function = (EObject element) -> {
          this.addAllDatamartProperties(workSet, sd, cc, element);
        };
        IteratorExtensions.<EObject>forEach(navigation.eAllContents(), _function);
      }
      boolean _isNullOrEmpty = IterableExtensions.isNullOrEmpty(((DatamartEntity)eObject).getAttributes());
      if (_isNullOrEmpty) {
        DatamartAttributeUtil.fillEmptyAttributes(((DatamartEntity)eObject));
      }
      EList<DatamartAttribute> _attributes = ((DatamartEntity)eObject).getAttributes();
      for (final DatamartAttribute datamartAttribute : _attributes) {
        {
          LEntityAttribute attribute = datamartAttribute.getAttributeRef();
          if (((((!attribute.isId()) && (!attribute.isUuid())) && (!attribute.isVersion())) && (!attribute.isTransient()))) {
            boolean _isAuthorized = this.datamartInferrer.isAuthorized(workSet.getRole(), ((DatamartEntity)eObject).getEntityRef(), attribute.getName());
            if (_isAuthorized) {
              this.addDatamartAttribute(workSet, sd, cc, datamartAttribute);
            }
          }
        }
      }
    }
  }
  
  private void addDatamartEntityResultSet(final ReportGeneratorWorkSet workSet, final OdaDataSetHandle odseth, final String dataSetName, final DatamartDefinition datamart) {
    try {
      String selectColumns = "";
      CachedMetaData cmd = new CachedMetaData();
      ArrayList<OdaResultSetColumn> sd = new ArrayList<OdaResultSetColumn>();
      ArrayList<ComputedColumn> cc = new ArrayList<ComputedColumn>();
      workSet.setPosition(0);
      this.addAllDatamartProperties(workSet, sd, cc, datamart.getSource());
      workSet.putResultSetColumns(dataSetName, sd);
      workSet.putComputedColumns(dataSetName, cc);
      for (final ComputedColumn cc1 : cc) {
        boolean _isEmpty = selectColumns.isEmpty();
        if (_isEmpty) {
          selectColumns = cc1.getName();
        } else {
          selectColumns = selectColumns.concat(",").concat(cc1.getName());
        }
      }
      StringConcatenation _builder = new StringConcatenation();
      _builder.append("select ");
      _builder.append(selectColumns);
      _builder.append(" from ");
      String _name = datamart.getName();
      _builder.append(_name);
      odseth.setProperty("queryText", _builder.toString());
      cmd.setProperty(IDataSetModel.RESULT_SET_PROP, sd);
      odseth.setProperty(IDataSetModel.CACHED_METADATA_PROP, cmd);
      odseth.getElement().setProperty(IDataSetModel.RESULT_SET_PROP, sd);
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
  private void addDatamartAttribute(final ReportGeneratorWorkSet workSet, final ArrayList<OdaResultSetColumn> sd, final ArrayList<ComputedColumn> cc, final DatamartAttribute datamartAttribute) {
    LEntityAttribute attribute = datamartAttribute.getAttributeRef();
    IDataMart.EType etype = this.dtType.getBasicType(attribute);
    DataTypes dataType = DataTypes.typeFor(etype);
    boolean _equals = Objects.equal(dataType, DataTypes.ANY);
    if (_equals) {
      dataType = DataTypes.typeFor(attribute.getType());
    }
    String name = DatamartAttributeUtil.getAliasedAttributeName(datamartAttribute);
    for (final OdaResultSetColumn column : sd) {
      boolean _equalsIgnoreCase = column.getColumnName().equalsIgnoreCase(name);
      if (_equalsIgnoreCase) {
        return;
      }
    }
    OdaResultSetColumn st = new OdaResultSetColumn();
    st.setColumnName(name);
    st.setProperty("name", name);
    st.setNativeDataType(Integer.valueOf(dataType.getNativeOdaDataTypeId()));
    st.setNativeName(name);
    int _position = workSet.getPosition();
    int _plus = (_position + 1);
    workSet.setPosition(_plus);
    st.setPosition(Integer.valueOf(workSet.getPosition()));
    st.setDataType(dataType.getNativeOdaDataTypeName());
    sd.add(st);
    ComputedColumn cs1 = StructureFactory.createComputedColumn();
    cs1.setName(name);
    cs1.setDisplayName(name);
    cs1.setExpression("dataSetRow[\"".concat(name).concat("\"]"));
    cs1.setDataType(dataType.getNativeOdaDataTypeName());
    this.setProperties(cs1, attribute);
    cc.add(cs1);
  }
  
  private void setProperties(final ComputedColumn column, final LEntityAttribute attribute) {
    LDataType lDataType = this.dtType.getLDataType(attribute);
    if ((lDataType != null)) {
      EList<LKeyAndValue> _properties = lDataType.getProperties();
      for (final LKeyAndValue prop : _properties) {
        column.setProperty(prop.getKey(), prop.getValue());
      }
    }
  }
  
  private CharSequence getDatamartClassName(final String alias, final DatamartDefinition datamart) {
    StringConcatenation _builder = new StringConcatenation();
    EObject _eContainer = datamart.eContainer();
    QualifiedName _fullyQualifiedName = this._iQualifiedNameProvider.getFullyQualifiedName(((LPackage) _eContainer));
    _builder.append(_fullyQualifiedName);
    _builder.append(".");
    String _name = datamart.getName();
    _builder.append(_name);
    _builder.append("Class");
    return _builder;
  }
  
  public void generateItems(final DatamartDefinition datamart, final ReportGeneratorWorkSet workSet, final ContainerItem container, final Element[] elements) {
    if ((elements != null)) {
      for (final Element element : elements) {
        try {
          boolean _matched = false;
          if (element instanceof Title) {
            _matched=true;
            container.addHeader(1, I18NKeyGenerator.key(((Title)element).getText()), ((Title)element).getText().replace("\"", ""), ((Title)element).getStyle());
          }
          if (!_matched) {
            if (element instanceof SubTitle) {
              _matched=true;
              container.addHeader(2, I18NKeyGenerator.key(((SubTitle)element).getText()), ((SubTitle)element).getText().replace("\"", ""), ((SubTitle)element).getStyle());
            }
          }
          if (!_matched) {
            if (element instanceof SubSubTitle) {
              _matched=true;
              container.addHeader(3, I18NKeyGenerator.key(((SubSubTitle)element).getText()), ((SubSubTitle)element).getText().replace("\"", ""), ((SubSubTitle)element).getStyle());
            }
          }
          if (!_matched) {
            if (element instanceof Label) {
              _matched=true;
              container.addLabel(I18NKeyGenerator.key(((Label)element).getText()), ((Label)element).getText().replace("\"", ""), ((Label)element).getStyle());
            }
          }
          if (!_matched) {
            if (element instanceof Text) {
              _matched=true;
              boolean _equals = ((Text)element).getTextContentType().getLiteral().equals(BaseItem.CONTENT_TYPE_HTML);
              if (_equals) {
                container.addText(I18NKeyGenerator.key(((Text)element).getText()), ((Text)element).getText(), ((Text)element).getStyle(), BaseItem.CONTENT_TYPE_HTML);
              } else {
                container.addText(I18NKeyGenerator.key(((Text)element).getText()), ((Text)element).getText().replace("\"", ""), ((Text)element).getStyle());
              }
            }
          }
          if (!_matched) {
            if (element instanceof NonTranslatableText) {
              _matched=true;
              container.addText(((NonTranslatableText)element).getValue().replace("\"", ""), null);
            }
          }
          if (!_matched) {
            if (element instanceof AutoText) {
              _matched=true;
              if ((((AutoText)element).getType().equals(AutoTextEnum.ACTUAL_DATE) || ((AutoText)element).getType().equals(AutoTextEnum.ACTUAL_TIME))) {
                container.addTextData(((AutoText)element).getType(), ((AutoText)element).getStyle());
              } else {
                boolean _equals = ((AutoText)element).getType().equals(AutoTextEnum.REPORT_NAME);
                if (_equals) {
                  String text = workSet.getReport().getName();
                  container.addLabel(text, text.replace("\"", ""), ((AutoText)element).getStyle());
                } else {
                  container.addAutoText(((AutoText)element).getType().toString(), ((AutoText)element).getStyle());
                }
              }
            }
          }
          if (!_matched) {
            if (element instanceof StringBinder) {
              _matched=true;
              container.addTextData(datamart, ((StringBinder) element), ((StringBinder)element).getStyle());
            }
          }
          if (!_matched) {
            if (element instanceof DatamartTableAttribute) {
              _matched=true;
              EObject eObj = ((DatamartTableAttribute)element).eContainer();
              while (((((eObj != null) && 
                (!(eObj instanceof PageHeader))) && 
                (!(eObj instanceof PageFooter))) && 
                (!(eObj instanceof PageDetail)))) {
                eObj = eObj.eContainer();
              }
              if (((eObj instanceof PageHeader) || (eObj instanceof PageFooter))) {
                TableValueElement _column = ((DatamartTableAttribute) element).getColumn();
                if ((_column instanceof TableAttribute)) {
                  TableValueElement _column_1 = ((DatamartTableAttribute) element).getColumn();
                  IDataMart.EType _basicType = this.dtType.getBasicType(((TableAttribute) _column_1).getValueRef().getAttributeRef());
                  boolean _equals = Objects.equal(_basicType, IDataMart.EType.BLOPMAPPING);
                  if (_equals) {
                    container.addDataImage(((DatamartTableAttribute)element), ((DatamartTableAttribute)element).getStyle());
                  } else {
                    TableValueElement _column_2 = ((DatamartTableAttribute) element).getColumn();
                    DatamartAttribute datamartAttribute = ((TableAttribute) _column_2).getValueRef();
                    ArrayList<DatamartAttribute> datamartAttributes = CollectionLiterals.<DatamartAttribute>newArrayList(datamartAttribute);
                    container.addTextData(datamart, datamartAttributes, ((DatamartTableAttribute)element).getStyle());
                  }
                }
              } else {
                if ((element instanceof DatamartTableAttribute)) {
                  if (((((DatamartTableAttribute) element).getColumn() instanceof TableAttribute) && 
                    Objects.equal(this.dtType.getBasicType(((TableAttribute) ((DatamartTableAttribute) element).getColumn()).getValueRef().getAttributeRef()), IDataMart.EType.BLOPMAPPING))) {
                    container.addDataImage(((DatamartTableAttribute)element), ((DatamartTableAttribute)element).getStyle());
                  } else {
                    EObject _eContainer = ((DatamartTableAttribute)element).eContainer();
                    if ((_eContainer instanceof GridCell)) {
                      container.addData(((DatamartTableAttribute)element), ((DatamartTableAttribute)element).getStyle());
                    } else {
                      Object datamartAlias = null;
                      ArrayList<DatamartAttribute> hiddens = new ArrayList<DatamartAttribute>();
                      String dataSetName = Utilities.getDataSetName(((String)datamartAlias), datamart).toString();
                      OdaDataSetHandle dataSet = workSet.getDataSets().get(dataSetName);
                      if ((dataSet == null)) {
                        final ArrayList<DatamartAttribute> _converted_hiddens = (ArrayList<DatamartAttribute>)hiddens;
                        this.addDatamartSourceAndSet(datamart, workSet, ((String)datamartAlias), ((DatamartAttribute[])Conversions.unwrapArray(_converted_hiddens, DatamartAttribute.class)));
                        dataSet = workSet.getDataSets().get(dataSetName);
                      }
                      container.addData(((DatamartTableAttribute)element), dataSet, dataSetName, ((DatamartTableAttribute)element).getStyle());
                    }
                  }
                }
              }
            }
          }
          if (!_matched) {
            if (element instanceof Image) {
              _matched=true;
              this.addImage(workSet, container, ((Image)element), null);
            }
          }
          if (!_matched) {
            if (element instanceof DatamartTable) {
              _matched=true;
              Width _width = new Width("100%");
              this.addDatamartTable(datamart, workSet, container, ((DatamartTable)element), _width);
            }
          }
          if (!_matched) {
            if (element instanceof Grid) {
              _matched=true;
              this.addGrid(datamart, workSet, container, ((Grid)element), ((Grid)element).getStyle());
            }
          }
        } catch (final Throwable _t) {
          if (_t instanceof ContentException) {
            final ContentException ce = (ContentException)_t;
            ReportModelGenerator.LOGGER.error("{}", ce);
          } else if (_t instanceof Exception) {
            final Exception e = (Exception)_t;
            ReportModelGenerator.LOGGER.error("{}", e);
          } else {
            throw Exceptions.sneakyThrow(_t);
          }
        }
      }
    }
  }
  
  private void addDatamartTable(final DatamartDefinition datamart, final ReportGeneratorWorkSet workSet, final ContainerItem container, final DatamartTable datamartTable, final Attribute... attributes) {
    try {
      DatamartDefinition newDatamart = datamart;
      DatamartDefinition _datamartRef = datamartTable.getDatamartRef();
      boolean _tripleNotEquals = (_datamartRef != null);
      if (_tripleNotEquals) {
        newDatamart = datamartTable.getDatamartRef();
      }
      ArrayList<DatamartAttribute> hiddens = new ArrayList<DatamartAttribute>();
      String alias = datamartTable.getName();
      String dataSetName = Utilities.getDataSetName(alias, newDatamart).toString();
      OdaDataSetHandle dataSet = workSet.getDataSets().get(dataSetName);
      if ((dataSet == null)) {
        final ArrayList<DatamartAttribute> _converted_hiddens = (ArrayList<DatamartAttribute>)hiddens;
        this.addDatamartSourceAndSet(newDatamart, workSet, alias, ((DatamartAttribute[])Conversions.unwrapArray(_converted_hiddens, DatamartAttribute.class)));
        dataSet = workSet.getDataSets().get(dataSetName);
      }
      container.addTable(newDatamart, dataSet, datamartTable, workSet.getComputedColumns(dataSetName), ((DatamartTableGroup[])Conversions.unwrapArray(datamartTable.getGroups(), DatamartTableGroup.class)), datamartTable.getDetail().getStyle(), ((DatamartTableAttribute[])Conversions.unwrapArray(datamartTable.getDetail().getColumnFormatters(), DatamartTableAttribute.class)), datamartTable.getStyle(), attributes);
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
  private void addImage(final ReportGeneratorWorkSet workSet, final ContainerItem container, final Image imageData, final Style style, final Attribute... attributes) {
    String _literal = imageData.getSize().getLiteral();
    double _scale = imageData.getScale();
    double _heightValue = imageData.getHeightValue();
    UnitEnum _heightUnit = imageData.getHeightUnit();
    double _widthValue = imageData.getWidthValue();
    UnitEnum _widthUnit = imageData.getWidthUnit();
    String _literal_1 = imageData.getSourceType().getLiteral();
    String _filename = imageData.getFilename();
    ImageItem image = new ImageItem(workSet, 
      null, _literal, _scale, _heightValue, _heightUnit, _widthValue, _widthUnit, _literal_1, _filename);
    container.add(image, style, attributes);
  }
  
  private void addGrid(final DatamartDefinition datamart, final ReportGeneratorWorkSet workSet, final ContainerItem container, final Grid grid, final Style style, final Attribute... attributes) {
    try {
      Object datamartAlias = null;
      ArrayList<DatamartAttribute> hiddens = new ArrayList<DatamartAttribute>();
      String dataSetName = Utilities.getDataSetName(((String)datamartAlias), datamart).toString();
      OdaDataSetHandle dataSet = workSet.getDataSets().get(dataSetName);
      if ((dataSet == null)) {
        final ArrayList<DatamartAttribute> _converted_hiddens = (ArrayList<DatamartAttribute>)hiddens;
        this.addDatamartSourceAndSet(datamart, workSet, ((String)datamartAlias), ((DatamartAttribute[])Conversions.unwrapArray(_converted_hiddens, DatamartAttribute.class)));
        dataSet = workSet.getDataSets().get(dataSetName);
      }
      List<ComputedColumn> _computedColumns = workSet.getComputedColumns(dataSetName);
      final GridItem gridItem = new GridItem(workSet, dataSet, _computedColumns, grid);
      List<Attribute> attributeList = CollectionLiterals.<Attribute>newArrayList();
      for (final Attribute attribute : attributes) {
        attributeList.add(attribute);
      }
      String propValue = "";
      double _widthValue = grid.getWidthValue();
      boolean _tripleNotEquals = (_widthValue != 0);
      if (_tripleNotEquals) {
        propValue = workSet.getLocalizedDoubleValue(gridItem.getHandle(), grid.getWidthValue());
      } else {
        propValue = "100%";
      }
      Width _width = new Width(propValue);
      attributeList.add(_width);
      Attribute[] newAttributes = attributeList.<Attribute>toArray(new Attribute[attributeList.size()]);
      if (((grid.getVisibilityItem() != null) && grid.getVisibilityItem().isVisibility())) {
        DataUtils.addVisibility(gridItem.getHandle(), grid.getVisibilityItem().getVisibilityAttribute());
      }
      int rowNo = 0;
      HashMap<Integer, Double> maxCellWidthMap = CollectionLiterals.<Integer, Double>newHashMap();
      EList<GridRow> _rows = grid.getRows();
      for (final GridRow row : _rows) {
        {
          ReportItemHandle _handle = gridItem.getHandle();
          DesignElementHandle _get = ((GridHandle) _handle).getRows().get(rowNo);
          RowHandle rowHandle = ((RowHandle) _get);
          if (((row.getVisibilityItem() != null) && row.getVisibilityItem().isVisibility())) {
            DataUtils.addVisibility(rowHandle, row.getVisibilityItem().getVisibilityAttribute());
          }
          int columnNo = 0;
          EList<GridCell> _cells = row.getCells();
          for (final GridCell cell : _cells) {
            {
              double _widthValue_1 = cell.getWidthValue();
              boolean _notEquals = (_widthValue_1 != 0);
              if (_notEquals) {
                DesignElementHandle cellHandle = rowHandle.getCells().get(columnNo);
                StringConcatenation _builder = new StringConcatenation();
                String _localizedDoubleValue = workSet.getLocalizedDoubleValue(gridItem.getHandle(), cell.getWidthValue());
                _builder.append(_localizedDoubleValue);
                cellHandle.setStringProperty(CssPropertyConstants.WIDTH, _builder.toString());
                if (((maxCellWidthMap.isEmpty() || (maxCellWidthMap.get(Integer.valueOf(columnNo)) == null)) || ((maxCellWidthMap.get(Integer.valueOf(columnNo))).doubleValue() < cell.getWidthValue()))) {
                  maxCellWidthMap.put(Integer.valueOf(columnNo), Double.valueOf(cell.getWidthValue()));
                }
              }
              Style _style = cell.getStyle();
              boolean _tripleNotEquals_1 = (_style != null);
              if (_tripleNotEquals_1) {
                gridItem.applyCellStyle(rowHandle, columnNo, cell.getStyle());
              }
              if (((cell.getVisibilityItem() != null) && cell.getVisibilityItem().isVisibility())) {
                DesignElementHandle cellHandle_1 = rowHandle.getCells().get(columnNo);
                DataUtils.addVisibility(cellHandle_1, cell.getVisibilityItem().getVisibilityAttribute());
              }
              this.generateItems(datamart, workSet, gridItem.getCell(columnNo, rowNo).setColumnSpan(cell.getColumnspan()), ((Element[])Conversions.unwrapArray(cell.getElements(), Element.class)));
              columnNo = (columnNo + 1);
            }
          }
          Style _style = row.getStyle();
          boolean _tripleNotEquals_1 = (_style != null);
          if (_tripleNotEquals_1) {
            gridItem.applyRowStyle(rowNo, row.getStyle());
          }
          double _heightValue = row.getHeightValue();
          boolean _tripleNotEquals_2 = (_heightValue != 0);
          if (_tripleNotEquals_2) {
            gridItem.setRowHeight(rowNo, row.getHeightValue());
          }
          rowNo = (rowNo + 1);
        }
      }
      final BiConsumer<Integer, Double> _function = (Integer columnIdx, Double columnWidth) -> {
        try {
          if (((columnWidth).doubleValue() != 0.0)) {
            ReportItemHandle _handle = gridItem.getHandle();
            DesignElementHandle _get = ((GridHandle) _handle).getColumns().get((columnIdx).intValue());
            StringConcatenation _builder = new StringConcatenation();
            String _localizedDoubleValue = workSet.getLocalizedDoubleValue(gridItem.getHandle(), (columnWidth).doubleValue());
            _builder.append(_localizedDoubleValue);
            ((ColumnHandle) _get).setStringProperty(CssPropertyConstants.WIDTH, _builder.toString());
          }
        } catch (Throwable _e) {
          throw Exceptions.sneakyThrow(_e);
        }
      };
      maxCellWidthMap.forEach(_function);
      container.add(gridItem, style, newAttributes);
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
  @Override
  public TreeAppendable createAppendable(final EObject context, final ImportManager importManager, final GeneratorConfig config) {
    TreeAppendable _xblockexpression = null;
    {
      this.setBuilder(context.eResource());
      this._basicDslGeneratorUtils.addImportFor(this, importManager, this._typeReferenceBuilder, ReportGeneratorWorkSet.class, HorizontalLayout.class, ViewLayoutManager.class, BrowserFrame.class, StreamResource.class, Sizeable.Unit.class, Button.class, com.vaadin.ui.Label.class, IEventBroker.class, EventHandler.class, Event.class, EventUtils.class, EventBrokerMsg.class, CustomMsgException.class, IReportProvider.Rendering.class, AbstractComponent.class, UUID.class, Container.Filter.class, IToolbarAction.class, HashMap.class);
      _xblockexpression = super.createAppendable(context, importManager, config);
    }
    return _xblockexpression;
  }
  
  public void internalDoGenerate(final EObject orgModel, final IFileSystemAccess fsa) {
    if (orgModel instanceof JvmDeclaredType) {
      _internalDoGenerate((JvmDeclaredType)orgModel, fsa);
      return;
    } else if (orgModel instanceof ReportModel) {
      _internalDoGenerate((ReportModel)orgModel, fsa);
      return;
    } else if (orgModel != null) {
      _internalDoGenerate(orgModel, fsa);
      return;
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(orgModel, fsa).toString());
    }
  }
}