}
			else if (parameter.getClassName().equals("java.lang.Integer"))
			{
				return new Integer(value);
			}
			else if (parameter.getClassName().equals("java.lang.Long"))
			{
				return new Long(value);
			}
			else if (parameter.getClassName().equals("java.math.BigDecimal"))
			{
				return new BigDecimal(value);
			}
			else if (parameter.getClassName().equals("java.util.Date"))
			{
				return dateProvider.parseDate(value);
			}
			else if (parameter.getClassName().equals("java.sql.Date"))
			{
				return dateProvider.parseDate(value);
			}
			else if (parameter.getClassName().equals("java.sql.Timestamp"))
			{
				long time = dateProvider.parseDate(value).getTime();
				return new Timestamp(time);
			}
		}
		catch (Exception e)
		{
			throw new ProviderException(
				parameter.getName() + " Invalid: " + e.getMessage());
		}

		throw new ProviderException(
			parameter.getName() + " currently unsupported!");
	}

	public List getReportParameters(Report report, String type)
		throws ProviderException
	{
		List parameters = new ArrayList();

		List allParameters = report.getParameters();

		if (allParameters != null)
		{
			Iterator iterator = allParameters.iterator();

			while (iterator.hasNext())
			{
				ReportParameterMap rpMap = (ReportParameterMap) iterator.next();

				if (rpMap.getReportParameter().getType().equals(type))
				{
					parameters.add(rpMap.getReportParameter());
				}
			}
		}

		return parameters;
	}	

	public void loadReportParameterValues(
		List reportParameters,
		Map parameters)
		throws ProviderException
	{
		for (int i = 0; i < reportParameters.size(); i++)
		{
			ReportParameterMap rpMap =
				(ReportParameterMap) reportParameters.get(i);
			ReportParameter rp = rpMap.getReportParameter();

			try
			{
				if (rp.getType().equals(ReportParameter.LIST_PARAM)
					|| rp.getType().equals(ReportParameter.QUERY_PARAM))
				{
					if (rp.getValues() == null) // only load once...
					{
						log.debug("loading parameter values: " + rp.getName());
						rp.setValues(getParamValues(rp, parameters));
					}
				}
			}
			catch (Exception e)
			{
				log.error("Error loading parameter values: " + rp.getName());
				throw new ProviderException(
					"loadReportParameterValues: " + e.getMessage());
			}
		}
	}

	public Map getReportParametersMap(
		List reportParameters,
		Map origParameters)
		throws ProviderException
	{
		Map map = new HashMap();

		// if multiple selections, use origParameters; otherwise, use
		// parameters
		Map parameters = new SingleValueMap(origParameters);

		Iterator iterator = reportParameters.iterator();
		while (iterator.hasNext())
		{
			ReportParameterMap rpMap = (ReportParameterMap) iterator.next();

			ReportParameter reportParameter = rpMap.getReportParameter();

			// if we are expecting multiple selections, convert the array of
			// parameters
			// into a comma-delimited string so that it can be used in the SQL
			// where
			// clause. Otherwise, just expect a simple String
			if (reportParameter.isMultipleSelect())
			{
				Object[] values =
					(String[]) origParameters.get(reportParameter.getName());				

				// load up the StringBuffer with the multiple selections.
				String s = buildMultipleSelectString(reportParameter, values);

				// save the parameter into the Map
				map.put(reportParameter.getName(), s);

				log.debug(
					reportParameter.getName()
						+ " => "
						+ map.get(reportParameter.getName()));
			}
			else
			{
				String value =
					(String) parameters.get(reportParameter.getName());
				if (value != null)
				{
					try
					{
						Object object = parseParameter(reportParameter, value);
						map.put(reportParameter.getName(), object);
					}
					catch (Exception e)
					{
						log.warn(
							"Error setting parameter: "
								+ reportParameter.getName()
								+ " : "
								+ e.getMessage());
					}
				}
			}
		}

		return map;
	}

	private String buildMultipleSelectString(
		ReportParameter reportParameter,
		Object[] values)
	{
		StringBuffer sb = new StringBuffer();

		for (int j = 0; j < values.length; j++)
		{
			String value = "";

			if (values[j] instanceof ReportParameterValue)
			{
				value = ((ReportParameterValue) values[j]).getId().toString();
			}
			else
			{
				value = (String) values[j];
			}

			if (j > 0)
			{
				sb.append(",");
			}
			if (reportParameter.getClassName().equals("java.lang.String"))
			{
				sb.append("'" + value + "'");
			}
			else
			{
				sb.append(value);
			}
		}

		return sb.toString();
	}

	public boolean validateParameters(List reportParameters, Map parameters)
		throws ProviderException
	{
		parameters = new SingleValueMap(parameters);

		if (reportParameters != null && reportParameters.size() > 0)
		{
			Iterator iterator = reportParameters.iterator();
			while (iterator.hasNext())
			{
				ReportParameterMap rpMap = (ReportParameterMap) iterator.next();

				ReportParameter param = rpMap.getReportParameter();

				if (!parameters.containsKey(param.getName())
					&& rpMap.isRequired())
				{
					throw new ProviderException(LocalStrings
							.getString(LocalStrings.ERROR_PARAMETER_REQUIRED)
							+ ": " + param.getDescription());
				}

				if (param.getType().equals(ReportParameter.TEXT_PARAM)
					|| param.getType().equals(ReportParameter.DATE_PARAM))
				{
					String value = (String) parameters.get(param.getName());

					if (value != null && value.length() > 0)
					{
						try
						{
							validateParameter(param, value);
						}
						catch (Exception e)
						{
							throw new ProviderException(e.getMessage());
						}
					}
					else if (rpMap.isRequired())
					{
						throw new ProviderException(LocalStrings
								.getString(LocalStrings.ERROR_PARAMETER_REQUIRED)
								+ ": " + param.getDescription());
					}
				}
			}
		}

		return true;
	}

	public List getAvailableParameters(Report report) throws ProviderException
	{
		List parameters = getReportParameters();

		Iterator iterator = parameters.iterator();
		while (iterator.hasNext())
		{
			ReportParameter rp = (ReportParameter) iterator.next();

			Iterator reportIterator = report.getParameters().iterator();
			while (reportIterator.hasNext())
			{
				ReportParameterMap rpMap =
					(ReportParameterMap) reportIterator.next();

				if (rp.getId().equals(rpMap.getReportParameter().getId()))
				{
					parameters.remove(rp);
					iterator = parameters.iterator();
				}
			}
		}

		return parameters;
	}

	public ReportParameter getReportParameter(Integer id)
		throws ProviderException
	{
		return paramPersistenceProvider.getReportParameter(id);
	}
	
	public ReportParameter getReportParameter(String name)
		throws ProviderException
	{
		return paramPersistenceProvider.getReportParameter(name);
	}

	public List getReportParameters() throws ProviderException
	{
		return paramPersistenceProvider.getReportParameters();
	}

	public ReportParameter insertReportParameter(ReportParameter reportParameter)
		throws ProviderException
	{
		return paramPersistenceProvider.insertReportParameter(reportParameter);
	}

	public void updateReportParameter(ReportParameter reportParameter)
		throws ProviderException
	{
		paramPersistenceProvider.updateReportParameter(reportParameter);
	}

	public void deleteReportParameter(ReportParameter reportParameter)
		throws ProviderException
	{
		paramPersistenceProvider.deleteReportParameter(reportParameter);
	}

	public void setDataSourceProvider(DataSourceProvider dataSourceProvider)
	{
		this.dataSourceProvider = dataSourceProvider;
	}

	public void setDateProvider(DateProvider dateProvider)
	{
		this.dateProvider = dateProvider;
	}

}