package net.sf.jasperreports.engine.fill;

import java.sql.Connection;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.TimeZone;
import net.sf.jasperreports.engine.JRAbstractScriptlet;
import net.sf.jasperreports.engine.JRDataSource;
import net.sf.jasperreports.engine.JRDataset;
import net.sf.jasperreports.engine.JRDefaultScriptlet;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRExpression;
import net.sf.jasperreports.engine.JRField;
import net.sf.jasperreports.engine.JRGroup;
import net.sf.jasperreports.engine.JRParameter;
import net.sf.jasperreports.engine.JRPropertiesHolder;
import net.sf.jasperreports.engine.JRPropertiesMap;
import net.sf.jasperreports.engine.JRQuery;
import net.sf.jasperreports.engine.JRRuntimeException;
import net.sf.jasperreports.engine.JRSortField;
import net.sf.jasperreports.engine.JRVariable;
import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRSortableDataSource;
import net.sf.jasperreports.engine.design.JRDesignVariable;
import net.sf.jasperreports.engine.query.JRQueryExecuter;
import net.sf.jasperreports.engine.query.JRQueryExecuterFactory;
import net.sf.jasperreports.engine.util.JRClassLoader;
import net.sf.jasperreports.engine.util.JRQueryExecuterUtils;
import net.sf.jasperreports.engine.util.JRResourcesUtil;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class JRFillDataset implements JRDataset {
  private static final Log log = LogFactory.getLog(JRFillDataset.class);
  
  private final JRBaseFiller filler;
  
  private final JRDataset parent;
  
  private final boolean isMain;
  
  protected JRQuery query = null;
  
  private boolean useDatasourceParamValue = false;
  
  private boolean useConnectionParamValue = false;
  
  protected JRFillParameter[] parameters = null;
  
  protected Map parametersMap = null;
  
  protected JRFillField[] fields = null;
  
  protected Map fieldsMap = null;
  
  protected JRFillVariable[] variables = null;
  
  protected Map variablesMap = null;
  
  protected Set variableCalculationReqs;
  
  protected JRFillElementDataset[] elementDatasets;
  
  protected JRFillElementDataset[] origElementDatasets;
  
  protected JRFillGroup[] groups = null;
  
  protected String resourceBundleBaseName = null;
  
  protected byte whenResourceMissingType;
  
  protected String scriptletClassName = null;
  
  protected JRDataSource dataSource = null;
  
  protected Locale locale = null;
  
  protected ResourceBundle resourceBundle = null;
  
  protected TimeZone timeZone = null;
  
  protected int reportCount = 0;
  
  protected JRCalculator calculator = null;
  
  protected JRAbstractScriptlet scriptlet = null;
  
  protected Integer reportMaxCount = null;
  
  private JRQueryExecuter queryExecuter;
  
  protected JRFillDataset(JRBaseFiller filler, JRDataset dataset, JRFillObjectFactory factory) {
    factory.put(dataset, this);
    this.filler = filler;
    this.parent = dataset;
    this.isMain = dataset.isMainDataset();
    this.scriptletClassName = dataset.getScriptletClass();
    this.resourceBundleBaseName = dataset.getResourceBundle();
    this.whenResourceMissingType = dataset.getWhenResourceMissingType();
    this.query = dataset.getQuery();
    setParameters(dataset, factory);
    setFields(dataset, factory);
    setVariables(dataset, factory);
    setGroups(dataset, factory);
  }
  
  private void setParameters(JRDataset dataset, JRFillObjectFactory factory) {
    JRParameter[] jrParameters = dataset.getParameters();
    if (jrParameters != null && jrParameters.length > 0) {
      this.parameters = new JRFillParameter[jrParameters.length];
      this.parametersMap = new HashMap();
      for (int i = 0; i < this.parameters.length; i++) {
        this.parameters[i] = factory.getParameter(jrParameters[i]);
        this.parametersMap.put(this.parameters[i].getName(), this.parameters[i]);
      } 
    } 
  }
  
  private void setGroups(JRDataset dataset, JRFillObjectFactory factory) {
    JRGroup[] jrGroups = dataset.getGroups();
    if (jrGroups != null && jrGroups.length > 0) {
      this.groups = new JRFillGroup[jrGroups.length];
      for (int i = 0; i < this.groups.length; i++)
        this.groups[i] = factory.getGroup(jrGroups[i]); 
    } 
  }
  
  private void setVariables(JRDataset dataset, JRFillObjectFactory factory) {
    JRVariable[] jrVariables = dataset.getVariables();
    if (jrVariables != null && jrVariables.length > 0) {
      List variableList = new ArrayList(jrVariables.length * 3);
      this.variablesMap = new HashMap();
      for (int i = 0; i < jrVariables.length; i++)
        addVariable(jrVariables[i], variableList, factory); 
      setVariables(variableList);
    } 
  }
  
  private JRFillVariable addVariable(JRVariable parentVariable, List variableList, JRFillObjectFactory factory) {
    JRVariable jRVariable1, varianceVar, countVar;
    JRFillVariable jRFillVariable1, fillVarianceVar, fillCountVar;
    JRVariable sumVar;
    JRFillVariable fillSumVar, variable = factory.getVariable(parentVariable);
    byte calculation = variable.getCalculation();
    switch (calculation) {
      case 3:
      case 7:
        jRVariable1 = createHelperVariable(parentVariable, "_COUNT", (byte)1);
        jRFillVariable1 = addVariable(jRVariable1, variableList, factory);
        variable.setHelperVariable(jRFillVariable1, (byte)0);
        sumVar = createHelperVariable(parentVariable, "_SUM", (byte)2);
        fillSumVar = addVariable(sumVar, variableList, factory);
        variable.setHelperVariable(fillSumVar, (byte)1);
        break;
      case 6:
        varianceVar = createHelperVariable(parentVariable, "_VARIANCE", (byte)7);
        fillVarianceVar = addVariable(varianceVar, variableList, factory);
        variable.setHelperVariable(fillVarianceVar, (byte)2);
        break;
      case 10:
        countVar = createDistinctCountHelperVariable(parentVariable);
        fillCountVar = addVariable(countVar, variableList, factory);
        variable.setHelperVariable(fillCountVar, (byte)0);
        break;
    } 
    variableList.add(variable);
    return variable;
  }
  
  private JRVariable createHelperVariable(JRVariable variable, String nameSuffix, byte calculation) {
    JRDesignVariable helper = new JRDesignVariable();
    helper.setName(variable.getName() + nameSuffix);
    helper.setValueClassName(variable.getValueClassName());
    helper.setIncrementerFactoryClassName(variable.getIncrementerFactoryClassName());
    helper.setResetType(variable.getResetType());
    helper.setResetGroup(variable.getResetGroup());
    helper.setIncrementType(variable.getIncrementType());
    helper.setIncrementGroup(variable.getIncrementGroup());
    helper.setCalculation(calculation);
    helper.setSystemDefined(true);
    helper.setExpression(variable.getExpression());
    return (JRVariable)helper;
  }
  
  private JRVariable createDistinctCountHelperVariable(JRVariable variable) {
    JRDesignVariable helper = new JRDesignVariable();
    helper.setName(variable.getName() + "_DISTINCT_COUNT");
    helper.setValueClassName(variable.getValueClassName());
    helper.setIncrementerFactoryClassName(JRDistinctCountIncrementerFactory.class.getName());
    helper.setResetType((byte)1);
    if (variable.getIncrementType() != 5)
      helper.setResetType(variable.getIncrementType()); 
    helper.setResetGroup(variable.getIncrementGroup());
    helper.setCalculation((byte)0);
    helper.setSystemDefined(true);
    helper.setExpression(variable.getExpression());
    return (JRVariable)helper;
  }
  
  private void setVariables(List variableList) {
    this.variables = new JRFillVariable[variableList.size()];
    this.variables = (JRFillVariable[])variableList.toArray((Object[])this.variables);
    for (int i = 0; i < this.variables.length; i++)
      this.variablesMap.put(this.variables[i].getName(), this.variables[i]); 
  }
  
  private void setFields(JRDataset dataset, JRFillObjectFactory factory) {
    JRField[] jrFields = dataset.getFields();
    if (jrFields != null && jrFields.length > 0) {
      this.fields = new JRFillField[jrFields.length];
      this.fieldsMap = new HashMap();
      for (int i = 0; i < this.fields.length; i++) {
        this.fields[i] = factory.getField(jrFields[i]);
        this.fieldsMap.put(this.fields[i].getName(), this.fields[i]);
      } 
    } 
  }
  
  protected void createCalculator(JasperReport jasperReport) throws JRException {
    setCalculator(createCalculator(jasperReport, this));
  }
  
  protected void setCalculator(JRCalculator calculator) {
    this.calculator = calculator;
  }
  
  protected static JRCalculator createCalculator(JasperReport jasperReport, JRDataset dataset) throws JRException {
    JREvaluator evaluator = JasperCompileManager.loadEvaluator(jasperReport, dataset);
    return new JRCalculator(evaluator);
  }
  
  protected void initCalculator() throws JRException {
    this.calculator.init(this);
  }
  
  protected void inheritFromMain() {
    if (this.resourceBundleBaseName == null && !this.isMain) {
      this.resourceBundleBaseName = this.filler.mainDataset.resourceBundleBaseName;
      this.whenResourceMissingType = this.filler.mainDataset.whenResourceMissingType;
    } 
  }
  
  protected JRAbstractScriptlet createScriptlet() throws JRException {
    JRDefaultScriptlet jRDefaultScriptlet;
    JRAbstractScriptlet tmpScriptlet = null;
    if (this.scriptletClassName != null) {
      try {
        Class scriptletClass = JRClassLoader.loadClassForName(this.scriptletClassName);
        tmpScriptlet = scriptletClass.newInstance();
      } catch (ClassNotFoundException e) {
        throw new JRException("Error loading scriptlet class : " + this.scriptletClassName, e);
      } catch (Exception e) {
        throw new JRException("Error creating scriptlet class instance : " + this.scriptletClassName, e);
      } 
    } else {
      jRDefaultScriptlet = new JRDefaultScriptlet();
    } 
    return (JRAbstractScriptlet)jRDefaultScriptlet;
  }
  
  protected void initElementDatasets(JRFillObjectFactory factory) {
    this.elementDatasets = factory.getElementDatasets(this);
  }
  
  protected void filterElementDatasets(JRFillElementDataset elementDataset) {
    this.origElementDatasets = this.elementDatasets;
    this.elementDatasets = new JRFillElementDataset[] { elementDataset };
  }
  
  protected void restoreElementDatasets() {
    if (this.origElementDatasets != null) {
      this.elementDatasets = this.origElementDatasets;
      this.origElementDatasets = null;
    } 
  }
  
  protected ResourceBundle loadResourceBundle() {
    ResourceBundle loadedBundle;
    if (this.resourceBundleBaseName == null) {
      loadedBundle = null;
    } else {
      loadedBundle = JRResourcesUtil.loadResourceBundle(this.resourceBundleBaseName, this.locale);
    } 
    return loadedBundle;
  }
  
  protected void setParameterValues(Map parameterValues) throws JRException {
    parameterValues.put("REPORT_PARAMETERS_MAP", parameterValues);
    this.reportMaxCount = (Integer)parameterValues.get("REPORT_MAX_COUNT");
    this.locale = (Locale)parameterValues.get("REPORT_LOCALE");
    if (this.locale == null) {
      this.locale = Locale.getDefault();
      parameterValues.put("REPORT_LOCALE", this.locale);
    } 
    this.resourceBundle = (ResourceBundle)parameterValues.get("REPORT_RESOURCE_BUNDLE");
    if (this.resourceBundle == null) {
      this.resourceBundle = loadResourceBundle();
      if (this.resourceBundle != null)
        parameterValues.put("REPORT_RESOURCE_BUNDLE", this.resourceBundle); 
    } 
    this.timeZone = (TimeZone)parameterValues.get("REPORT_TIME_ZONE");
    if (this.timeZone == null) {
      this.timeZone = TimeZone.getDefault();
      parameterValues.put("REPORT_TIME_ZONE", this.timeZone);
    } 
    this.scriptlet = (JRAbstractScriptlet)parameterValues.get("REPORT_SCRIPTLET");
    if (this.scriptlet == null) {
      this.scriptlet = createScriptlet();
      parameterValues.put("REPORT_SCRIPTLET", this.scriptlet);
    } 
    this.scriptlet.setData(this.parametersMap, this.fieldsMap, this.variablesMap, this.groups);
    setFillParameterValues(parameterValues);
  }
  
  protected void initDatasource() throws JRException {
    this.queryExecuter = null;
    this.dataSource = (JRDataSource)getParameterValue("REPORT_DATA_SOURCE");
    if (!this.useDatasourceParamValue && (this.useConnectionParamValue || this.dataSource == null)) {
      this.dataSource = createQueryDatasource();
      setParameter("REPORT_DATA_SOURCE", this.dataSource);
    } 
    JRSortField[] sortFields = getSortFields();
    if (sortFields != null && sortFields.length > 0) {
      this.dataSource = (JRDataSource)new JRSortableDataSource(this.dataSource, (JRField[])this.fields, sortFields, this.locale);
      setParameter("REPORT_DATA_SOURCE", this.dataSource);
    } 
  }
  
  private void setFillParameterValues(Map parameterValues) throws JRException {
    if (this.parameters != null && this.parameters.length > 0)
      for (int i = 0; i < this.parameters.length; i++) {
        Object value = null;
        if (parameterValues.containsKey(this.parameters[i].getName())) {
          value = parameterValues.get(this.parameters[i].getName());
        } else if (!this.parameters[i].isSystemDefined()) {
          value = this.calculator.evaluate(this.parameters[i].getDefaultValueExpression(), (byte)3);
          if (value != null)
            parameterValues.put(this.parameters[i].getName(), value); 
        } 
        setParameter(this.parameters[i], value);
      }  
  }
  
  private JRDataSource createQueryDatasource() throws JRException {
    if (this.query == null)
      return null; 
    try {
      if (log.isDebugEnabled())
        log.debug("Fill " + this.filler.fillerId + ": Creating " + this.query.getLanguage() + " query executer"); 
      JRQueryExecuterFactory queryExecuterFactory = JRQueryExecuterUtils.getQueryExecuterFactory(this.query.getLanguage());
      this.queryExecuter = queryExecuterFactory.createQueryExecuter(this.parent, this.parametersMap);
      this.filler.fillContext.setRunningQueryExecuter(this.queryExecuter);
      return this.queryExecuter.createDatasource();
    } finally {
      this.filler.fillContext.clearRunningQueryExecuter();
    } 
  }
  
  protected void reset() {
    this.useDatasourceParamValue = false;
    this.useConnectionParamValue = false;
  }
  
  protected void setDatasourceParameterValue(Map parameterValues, JRDataSource ds) {
    this.useDatasourceParamValue = true;
    if (ds != null)
      parameterValues.put("REPORT_DATA_SOURCE", ds); 
  }
  
  protected void setConnectionParameterValue(Map parameterValues, Connection conn) {
    this.useConnectionParamValue = true;
    if (conn != null)
      parameterValues.put("REPORT_CONNECTION", conn); 
  }
  
  protected void closeDatasource() {
    if (this.queryExecuter != null) {
      if (log.isDebugEnabled())
        log.debug("Fill " + this.filler.fillerId + ": closing query executer"); 
      this.queryExecuter.close();
      this.queryExecuter = null;
    } 
    reset();
  }
  
  protected void start() {
    this.reportCount = 0;
  }
  
  protected boolean next() throws JRException {
    boolean hasNext = false;
    if (this.dataSource != null) {
      boolean includeRow = true;
      JRExpression filterExpression = getFilterExpression();
      do {
        hasNext = advanceDataSource();
        if (!hasNext)
          continue; 
        setOldValues();
        this.calculator.estimateVariables();
        if (filterExpression != null) {
          Boolean filterExprResult = (Boolean)this.calculator.evaluate(filterExpression, (byte)2);
          includeRow = (filterExprResult != null && filterExprResult.booleanValue());
        } 
        if (includeRow)
          continue; 
        revertToOldValues();
      } while (hasNext && !includeRow);
      if (hasNext)
        this.reportCount++; 
    } 
    return hasNext;
  }
  
  protected void setOldValues() throws JRException {
    if (this.fields != null && this.fields.length > 0)
      for (int i = 0; i < this.fields.length; i++) {
        JRFillField field = this.fields[i];
        field.setPreviousOldValue(field.getOldValue());
        field.setOldValue(field.getValue());
        field.setValue(this.dataSource.getFieldValue(field));
      }  
    if (this.variables != null && this.variables.length > 0)
      for (int i = 0; i < this.variables.length; i++) {
        JRFillVariable variable = this.variables[i];
        variable.setPreviousOldValue(variable.getOldValue());
        variable.setOldValue(variable.getValue());
      }  
  }
  
  protected void revertToOldValues() {
    if (this.fields != null && this.fields.length > 0)
      for (int i = 0; i < this.fields.length; i++) {
        JRFillField field = this.fields[i];
        field.setValue(field.getOldValue());
        field.setOldValue(field.getPreviousOldValue());
      }  
    if (this.variables != null && this.variables.length > 0)
      for (int i = 0; i < this.variables.length; i++) {
        JRFillVariable variable = this.variables[i];
        variable.setValue(variable.getOldValue());
        variable.setOldValue(variable.getPreviousOldValue());
      }  
  }
  
  protected boolean advanceDataSource() throws JRException {
    boolean hasNext = ((this.reportMaxCount == null || this.reportMaxCount.intValue() > this.reportCount) && this.dataSource.next());
    return hasNext;
  }
  
  protected void setParameter(String parameterName, Object value) throws JRException {
    JRFillParameter parameter = (JRFillParameter)this.parametersMap.get(parameterName);
    if (parameter != null)
      setParameter(parameter, value); 
  }
  
  protected void setParameter(JRFillParameter parameter, Object value) throws JRException {
    if (value != null) {
      if (parameter.getValueClass().isInstance(value)) {
        parameter.setValue(value);
      } else {
        throw new JRException("Incompatible " + value.getClass().getName() + " value assigned to parameter " + parameter.getName() + " in the " + getName() + " dataset.");
      } 
    } else {
      parameter.setValue(value);
    } 
  }
  
  public Object getVariableValue(String variableName) {
    JRFillVariable var = (JRFillVariable)this.variablesMap.get(variableName);
    if (var == null)
      throw new JRRuntimeException("No such variable " + variableName); 
    return var.getValue();
  }
  
  public Object getParameterValue(String parameterName) {
    return getParameterValue(parameterName, false);
  }
  
  public Object getParameterValue(String parameterName, boolean ignoreMissing) {
    Object value;
    JRFillParameter param = (JRFillParameter)this.parametersMap.get(parameterName);
    if (param == null) {
      if (!ignoreMissing)
        throw new JRRuntimeException("No such parameter " + parameterName); 
      value = null;
    } else {
      value = param.getValue();
    } 
    return value;
  }
  
  public Object getFieldValue(String fieldName) {
    JRFillField var = (JRFillField)this.fieldsMap.get(fieldName);
    if (var == null)
      throw new JRRuntimeException("No such field " + fieldName); 
    return var.getValue();
  }
  
  protected static class VariableCalculationReq {
    String variableName;
    
    byte calculation;
    
    VariableCalculationReq(String variableName, byte calculation) {
      this.variableName = variableName;
      this.calculation = calculation;
    }
    
    public boolean equals(Object o) {
      if (o == null || !(o instanceof VariableCalculationReq))
        return false; 
      VariableCalculationReq r = (VariableCalculationReq)o;
      return (this.variableName.equals(r.variableName) && this.calculation == r.calculation);
    }
    
    public int hashCode() {
      return 31 * this.calculation + this.variableName.hashCode();
    }
  }
  
  protected void addVariableCalculationReq(String variableName, byte calculation) {
    if (this.variableCalculationReqs == null)
      this.variableCalculationReqs = new HashSet(); 
    this.variableCalculationReqs.add(new VariableCalculationReq(variableName, calculation));
  }
  
  protected void checkVariableCalculationReqs(JRFillObjectFactory factory) {
    if (this.variableCalculationReqs != null && !this.variableCalculationReqs.isEmpty()) {
      List variableList = new ArrayList(this.variables.length * 2);
      for (int i = 0; i < this.variables.length; i++) {
        JRFillVariable variable = this.variables[i];
        checkVariableCalculationReq(variable, variableList, factory);
      } 
      setVariables(variableList);
    } 
  }
  
  private void checkVariableCalculationReq(JRFillVariable variable, List variableList, JRFillObjectFactory factory) {
    if (hasVariableCalculationReq(variable, (byte)3) || hasVariableCalculationReq(variable, (byte)7)) {
      if (variable.getHelperVariable((byte)0) == null) {
        JRVariable countVar = createHelperVariable(variable, "_COUNT", (byte)1);
        JRFillVariable fillCountVar = factory.getVariable(countVar);
        checkVariableCalculationReq(fillCountVar, variableList, factory);
        variable.setHelperVariable(fillCountVar, (byte)0);
      } 
      if (variable.getHelperVariable((byte)1) == null) {
        JRVariable sumVar = createHelperVariable(variable, "_SUM", (byte)2);
        JRFillVariable fillSumVar = factory.getVariable(sumVar);
        checkVariableCalculationReq(fillSumVar, variableList, factory);
        variable.setHelperVariable(fillSumVar, (byte)1);
      } 
    } 
    if (hasVariableCalculationReq(variable, (byte)6))
      if (variable.getHelperVariable((byte)2) == null) {
        JRVariable varianceVar = createHelperVariable(variable, "_VARIANCE", (byte)7);
        JRFillVariable fillVarianceVar = factory.getVariable(varianceVar);
        checkVariableCalculationReq(fillVarianceVar, variableList, factory);
        variable.setHelperVariable(fillVarianceVar, (byte)2);
      }  
    if (hasVariableCalculationReq(variable, (byte)10))
      if (variable.getHelperVariable((byte)0) == null) {
        JRVariable countVar = createDistinctCountHelperVariable(variable);
        JRFillVariable fillCountVar = factory.getVariable(countVar);
        checkVariableCalculationReq(fillCountVar, variableList, factory);
        variable.setHelperVariable(fillCountVar, (byte)0);
      }  
    variableList.add(variable);
  }
  
  private boolean hasVariableCalculationReq(JRVariable var, byte calculation) {
    return this.variableCalculationReqs.contains(new VariableCalculationReq(var.getName(), calculation));
  }
  
  public String getName() {
    return this.parent.getName();
  }
  
  public String getScriptletClass() {
    return this.parent.getScriptletClass();
  }
  
  public JRParameter[] getParameters() {
    return (JRParameter[])this.parameters;
  }
  
  public Map getParametersMap() {
    return this.parametersMap;
  }
  
  public JRQuery getQuery() {
    return this.query;
  }
  
  public JRField[] getFields() {
    return (JRField[])this.fields;
  }
  
  public JRSortField[] getSortFields() {
    return this.parent.getSortFields();
  }
  
  public JRVariable[] getVariables() {
    return (JRVariable[])this.variables;
  }
  
  public JRGroup[] getGroups() {
    return (JRGroup[])this.groups;
  }
  
  public boolean isMainDataset() {
    return this.isMain;
  }
  
  public String getResourceBundle() {
    return this.parent.getResourceBundle();
  }
  
  public byte getWhenResourceMissingType() {
    return this.whenResourceMissingType;
  }
  
  public void setWhenResourceMissingType(byte whenResourceMissingType) {
    this.whenResourceMissingType = whenResourceMissingType;
  }
  
  public boolean hasProperties() {
    return this.parent.hasProperties();
  }
  
  public JRPropertiesMap getPropertiesMap() {
    return this.parent.getPropertiesMap();
  }
  
  public JRPropertiesHolder getParentProperties() {
    return null;
  }
  
  public JRExpression getFilterExpression() {
    return this.parent.getFilterExpression();
  }
  
  public Object clone() {
    return null;
  }
}