* (c) 2001 - 2013 OpenPlans

* This code is licensed under the GPL 2.0 license, available at the root

* application directory.

*/

    Logger LOGGER = Logging.getLogger(DefaultWebCoverageService111.class);

    private Catalog catalog;

    private GeoServer geoServer;

    private CoverageResponseDelegateFinder responseFactory;

    public DefaultWebCoverageService111(GeoServer geoServer,

            CoverageResponseDelegateFinder responseFactory) {

        this.geoServer = geoServer;

        this.catalog = geoServer.getCatalog();

        this.responseFactory = responseFactory;

    }

    public WCSInfo getServiceInfo() {

        return geoServer.getService(WCSInfo.class);

    }

    public WCSCapsTransformer getCapabilities(GetCapabilitiesType request) {

        // do the version negotiation dance

        List<String> provided = new ArrayList<String>();

        // provided.add("1.0.0");

        provided.add("1.1.0");

        provided.add("1.1.1");

        List<String> accepted = null;

        if (request.getAcceptVersions() != null)

            accepted = request.getAcceptVersions().getVersion();

        String version = RequestUtils.getVersionOws11(provided, accepted);

        // TODO: add support for 1.0.0 in here

        if ("1.1.0".equals(version) || "1.1.1".equals(version)) {

            WCSCapsTransformer capsTransformer = new WCSCapsTransformer(geoServer);

            capsTransformer.setEncoding(Charset.forName((getServiceInfo().getGeoServer()

                    .getSettings().getCharset())));

            return capsTransformer;

        }

        throw new WcsException("Could not understand version:" + version);

    }

    public DescribeCoverageTransformer describeCoverage(DescribeCoverageType request) {

        final String version = request.getVersion();

        if ("1.1.0".equals(version) || "1.1.1".equals(version)) {

            WCSInfo wcs = getServiceInfo();

            DescribeCoverageTransformer describeTransformer = new DescribeCoverageTransformer(wcs,

                    catalog, responseFactory);

            describeTransformer.setEncoding(Charset.forName(wcs.getGeoServer().getSettings()

                    .getCharset()));

            return describeTransformer;

        }

        throw new WcsException("Could not understand version:" + version);

    }

    @SuppressWarnings({ "deprecation", "unchecked" })

    public GridCoverage[] getCoverage(GetCoverageType request) {

        if (LOGGER.isLoggable(Level.FINEST)) {

            LOGGER.finest(new StringBuffer("execute CoverageRequest response. Called request is: ")

                    .append(request).toString());

        }

        WCSInfo wcs = getServiceInfo();

        CoverageInfo meta = null;

        GridCoverage2D coverage = null;

        try {

            CodeType identifier = request.getIdentifier();

            if (identifier == null)

                throw new WcsException("Internal error, the coverage identifier must not be null",

                        InvalidParameterValue, "identifier");

            meta = catalog.getCoverageByName(identifier.getValue());

            if (meta == null) {

                throw new WcsException("No such coverage: " + request.getIdentifier().getValue());

            }

            // first let's run some sanity checks on the inputs

            checkDomainSubset(meta, request.getDomainSubset(), wcs);

            checkRangeSubset(meta, request.getRangeSubset());

            checkOutput(meta, request.getOutput());

            // grab the format, the reader using the default params

            final GridCoverage2DReader reader = (GridCoverage2DReader) meta.getGridCoverageReader(

                    null, WCSUtils.getReaderHints(wcs));

            // handle spatial domain subset, if needed

            final GeneralEnvelope originalEnvelope = reader.getOriginalEnvelope();

            final BoundingBoxType bbox = request.getDomainSubset().getBoundingBox();

            final CoordinateReferenceSystem nativeCRS = originalEnvelope

                    .getCoordinateReferenceSystem();

            final GeneralEnvelope requestedEnvelopeInNativeCRS;

            final GeneralEnvelope requestedEnvelope;

            if (bbox != null) {

                // first off, parse the envelope corners

                double[] lowerCorner = new double[bbox.getLowerCorner().size()];

                double[] upperCorner = new double[bbox.getUpperCorner().size()];

                for (int i = 0; i < lowerCorner.length; i++) {

                    lowerCorner[i] = (Double) bbox.getLowerCorner().get(i);

                    upperCorner[i] = (Double) bbox.getUpperCorner().get(i);

                }

                requestedEnvelope = new GeneralEnvelope(lowerCorner, upperCorner);

                // grab the native crs

                // if no crs has beens specified, the native one is assumed

                if (bbox.getCrs() == null) {

                    requestedEnvelope.setCoordinateReferenceSystem(nativeCRS);

                    requestedEnvelopeInNativeCRS = requestedEnvelope;

                } else {

                    // otherwise we need to transform

                    final CoordinateReferenceSystem bboxCRS = CRS.decode(bbox.getCrs());

                    requestedEnvelope.setCoordinateReferenceSystem(bboxCRS);

                    if (!CRS.equalsIgnoreMetadata(bboxCRS, nativeCRS)) {

                        CoordinateOperationFactory of = CRS.getCoordinateOperationFactory(true);

                        CoordinateOperation co = of.createOperation(bboxCRS, nativeCRS);

                        requestedEnvelopeInNativeCRS = CRS.transform(co, requestedEnvelope);

                    } else {

                        requestedEnvelopeInNativeCRS = new GeneralEnvelope(requestedEnvelope);

                    }

                }

            } else {

                requestedEnvelopeInNativeCRS = reader.getOriginalEnvelope();

                requestedEnvelope = requestedEnvelopeInNativeCRS;

            }

            final GridCrsType gridCRS = request.getOutput().getGridCRS();

            // Compute the crs that the final coverage will be served into

            final CoordinateReferenceSystem targetCRS;

            if (gridCRS == null) {

                targetCRS = reader.getOriginalEnvelope().getCoordinateReferenceSystem();

            } else {

                targetCRS = CRS.decode(gridCRS.getGridBaseCRS());

            }

            //

            // Raster destination size

            //

            int elevationLevels = 0;

            double[] elevations = null;

            // grab the grid to world transformation

            MathTransform gridToCRS = reader.getOriginalGridToWorld(PixelInCell.CELL_CENTER);

            //

            // TIME Values

            //

            final List<Date> timeValues = new LinkedList<Date>();

            TimeSequenceType temporalSubset = request.getDomainSubset().getTemporalSubset();

            if (temporalSubset != null && temporalSubset.getTimePosition() != null

                    && temporalSubset.getTimePosition().size() > 0) {

                for (Iterator it = temporalSubset.getTimePosition().iterator(); it.hasNext();) {

                    Date tp = (Date) it.next();

                    timeValues.add(tp);

                }

            } else if (temporalSubset != null && temporalSubset.getTimePeriod() != null

                    && temporalSubset.getTimePeriod().size() > 0) {

                for (Iterator it = temporalSubset.getTimePeriod().iterator(); it.hasNext();) {

                    TimePeriodType tp = (TimePeriodType) it.next();

                    Date beginning = (Date) tp.getBeginPosition();

                    Date ending = (Date) tp.getEndPosition();

                    timeValues.add(beginning);

                    timeValues.add(ending);

                }

            }

            // now we have enough info to read the coverage, grab the parameters

            // and add the grid geometry info

            final GeneralEnvelope intersectionEnvelopeInSourceCRS = new GeneralEnvelope(

                    requestedEnvelopeInNativeCRS);

            intersectionEnvelopeInSourceCRS.intersect(originalEnvelope);

            final GridGeometry2D requestedGridGeometry = new GridGeometry2D(

                    PixelInCell.CELL_CENTER, gridToCRS, intersectionEnvelopeInSourceCRS, null);

            final ParameterValueGroup readParametersDescriptor = reader.getFormat()

                    .getReadParameters();

            GeneralParameterValue[] readParameters = CoverageUtils.getParameters(

                    readParametersDescriptor, meta.getParameters());

            readParameters = (readParameters != null ? readParameters

                    : new GeneralParameterValue[0]);

            //

            // Setting coverage reading params.

            //

            final ParameterValue requestedGridGeometryParam = new DefaultParameterDescriptor(

                    AbstractGridFormat.READ_GRIDGEOMETRY2D.getName().toString(),

                    GeneralGridGeometry.class, null, requestedGridGeometry).createValue();

            /*

             * Test if the parameter "TIME" is present in the WMS request, and by the way in the reading parameters. If it is the case, one can adds

             * it to the request. If an exception is thrown, we have nothing to do.

             */

            final List<GeneralParameterDescriptor> parameterDescriptors = readParametersDescriptor

                    .getDescriptor().descriptors();

            ParameterValue time = null;

            boolean hasTime = timeValues.size() > 0;

            ParameterValue elevation = null;

            boolean hasElevation = elevations != null && !Double.isNaN(elevations[0]);

            if (hasElevation || hasTime) {

                for (GeneralParameterDescriptor pd : parameterDescriptors) {

                    final String code = pd.getName().getCode();

                    //

                    // TIME

                    //

                    if (code.equalsIgnoreCase("TIME")) {

                        time = (ParameterValue) pd.createValue();

                        time.setValue(timeValues);

                    }

                    //

                    // ELEVATION

                    //

                    if (code.equalsIgnoreCase("ELEVATION")) {

                        elevation = (ParameterValue) pd.createValue();

                        elevation.setValue(elevations[0]);

                    }

                    // leave?

                    if ((hasElevation && elevation != null && hasTime && time != null)

                            || !hasElevation && hasTime && time != null || hasElevation

                            && elevation != null && !hasTime)

                        break;

                }

            }

            //

            // add read parameters

            //

            int addedParams = 1 + (hasTime ? 1 : 0) + (hasElevation ? 1 : 0);

            // add to the list

            GeneralParameterValue[] readParametersClone = new GeneralParameterValue[readParameters.length

                    + addedParams--];

            System.arraycopy(readParameters, 0, readParametersClone, 0, readParameters.length);

            readParametersClone[readParameters.length + addedParams--] = requestedGridGeometryParam;

            if (hasTime)

                readParametersClone[readParameters.length + addedParams--] = time;

            if (hasElevation)

                readParametersClone[readParameters.length + addedParams--] = elevation;

            readParameters = readParametersClone;

            // Check we're not being requested to read too much data from input (first check,

            // guesses the grid size using the information contained in CoverageInfo)

            WCSUtils.checkInputLimits(wcs, meta, reader, requestedGridGeometry);

            //

            // Check if we have a filter among the params

            //

            Filter filter = WCSUtils.getRequestFilter();

            if (filter != null) {

                readParameters = CoverageUtils.mergeParameter(parameterDescriptors, readParameters,

                        filter, "FILTER", "Filter");

            }

            //

            // make sure we work in streaming mode

            //

            // work in streaming fashion when JAI is involved

            readParameters = WCSUtils.replaceParameter(readParameters, Boolean.FALSE,

                    AbstractGridFormat.USE_JAI_IMAGEREAD);

            //

            // perform Read ...

            //

            coverage = (GridCoverage2D) reader.read(readParameters);

            if ((coverage == null) || !(coverage instanceof GridCoverage2D)) {

                throw new IOException("The requested coverage could not be found.");

            }

            // now that we have read the coverage double check the input size

            WCSUtils.checkInputLimits(wcs, coverage);

            // some raster sources do not really read less data (arcgrid for example), we may need to crop

            if (!intersectionEnvelopeInSourceCRS.contains(coverage.getEnvelope2D(), true)) {

                coverage = WCSUtils.crop(coverage, intersectionEnvelopeInSourceCRS);

            }

            /**

             * Band Select (works on just one field)

             */

            GridCoverage2D bandSelectedCoverage = coverage;

            String interpolationType = null;

            if (request.getRangeSubset() != null) {

                if (request.getRangeSubset().getFieldSubset().size() > 1) {

                    throw new WcsException("Multi field coverages are not supported yet");

                }

                FieldSubsetType field = (FieldSubsetType) request.getRangeSubset().getFieldSubset()

                        .get(0);

                interpolationType = field.getInterpolationType();

                // handle axis subset

                if (field.getAxisSubset().size() > 1) {

                    throw new WcsException("Multi axis coverages are not supported yet");

                }

                if (field.getAxisSubset().size() == 1) {

                    // prepare a support structure to quickly get the band index

                    // of a

                    // key

                    List<CoverageDimensionInfo> dimensions = meta.getDimensions();

                    Map<String, Integer> dimensionMap = new HashMap<String, Integer>();

                    for (int i = 0; i < dimensions.size(); i++) {

                        String keyName = dimensions.get(i).getName().replace(' ', '_');

                        dimensionMap.put(keyName, i);

                    }

                    // extract the band indexes

                    AxisSubsetType axisSubset = (AxisSubsetType) field.getAxisSubset().get(0);

                    List keys = axisSubset.getKey();

                    int[] bands = new int[keys.size()];

                    for (int j = 0; j < bands.length; j++) {

                        final String key = (String) keys.get(j);

                        Integer index = dimensionMap.get(key);

                        if (index == null)

                            throw new WcsException("Unknown field/axis/key combination "

                                    + field.getIdentifier().getValue() + "/"

                                    + axisSubset.getIdentifier() + "/" + key);

                        bands[j] = index;

                    }

                    // finally execute the band select

                    try {

                        bandSelectedCoverage = (GridCoverage2D) WCSUtils

                                .bandSelect(coverage, bands);

                    } catch (WcsException e) {

                        throw new WcsException(e.getLocalizedMessage());

                    }

                }

            }

            /**

             * Checking for supported Interpolation Methods

             */

            Interpolation interpolation = Interpolation.getInstance(Interpolation.INTERP_NEAREST);

            if (interpolationType != null) {

                if (interpolationType.equalsIgnoreCase("linear") || interpolationType.equalsIgnoreCase("bilinear")) {

                    interpolation = Interpolation.getInstance(Interpolation.INTERP_BILINEAR);

                } else if (interpolationType.equalsIgnoreCase("cubic") || interpolationType.equalsIgnoreCase("bicubic")) {

                    interpolation = Interpolation.getInstance(Interpolation.INTERP_BICUBIC);

                } else if (interpolationType.equalsIgnoreCase("nearest")) {

                    interpolation = Interpolation.getInstance(Interpolation.INTERP_NEAREST);

                }

            }

            // adjust the grid geometry to use the final bbox and crs

            final GeneralEnvelope intersectionEnvelope;

            boolean reprojectionNeeded = !CRS.equalsIgnoreMetadata(nativeCRS, targetCRS);

            if (reprojectionNeeded) {

                CoordinateOperationFactory of = CRS.getCoordinateOperationFactory(true);

                CoordinateOperation co = of.createOperation(nativeCRS, targetCRS);

                intersectionEnvelope = CRS.transform(co, intersectionEnvelopeInSourceCRS);

            } else {

                intersectionEnvelope = intersectionEnvelopeInSourceCRS;

            }

            // compute the output resolution

            double pixelSizeX;

            double pixelSizeY;

            if (gridCRS != null) {

                Double[] origin = (Double[]) gridCRS.getGridOrigin();

                Double[] offsets = (Double[]) gridCRS.getGridOffsets();

                // from the specification if grid origin is omitted and the crs

                // is 2d the default it's 0,0

                if (origin == null) {

                    origin = new Double[] { 0.0, 0.0 };

                }

                // if no offsets has been specified we try to default on the

                // native ones

                if (offsets == null) {

                    offsets = estimateOffsets(reader, gridCRS, gridToCRS, intersectionEnvelope,

                            reprojectionNeeded);

                }

                // building the actual transform for the resulting grid geometry

                AffineTransform tx;

                if (gridCRS.getGridType().equals(GridType.GT2dSimpleGrid.getXmlConstant())) {

                    tx = new AffineTransform(offsets[0], 0, 0, offsets[1], origin[0], origin[1]);

                } else if (gridCRS.getGridType().equals(GridType.GT2dGridIn2dCrs.getXmlConstant())) {

                    tx = new AffineTransform(offsets[0], offsets[1], offsets[2], offsets[3],

                            origin[0], origin[1]);

                } else {

                    tx = new AffineTransform(offsets[0], offsets[4], offsets[1], offsets[3],

                            origin[0], origin[1]);

                    if (origin.length != 3 || offsets.length != 6)

                        throw new WcsException("", InvalidParameterValue, "GridCRS");

                    //

                    // ELEVATIONS

                    //

                    // TODO: draft code ... it needs more study!

                    elevationLevels = (int) Math.round(requestedEnvelope.getUpperCorner()

                            .getOrdinate(2) - requestedEnvelope.getLowerCorner().getOrdinate(2));

                    // compute the elevation levels, we have elevationLevels values

                    if (elevationLevels > 0) {

                        elevations = new double[elevationLevels];

                        elevations[0] = requestedEnvelope.getLowerCorner().getOrdinate(2); // TODO put the extrema

                        elevations[elevationLevels - 1] = requestedEnvelope.getUpperCorner()

                                .getOrdinate(2);

                        if (elevationLevels > 2) {

                            final int adjustedLevelsNum = elevationLevels - 1;

                            double step = (elevations[elevationLevels - 1] - elevations[0])

                                    / adjustedLevelsNum;

                            for (int i = 1; i < adjustedLevelsNum; i++)

                                elevations[i] = elevations[i - 1] + step;

                        }

                    }

                }

                pixelSizeX = Math.abs(tx.getScaleX());

                pixelSizeY = Math.abs(tx.getScaleY());

                gridToCRS = new AffineTransform2D(tx);

            } else {

                Double[] offsets = estimateOffsets(reader, gridCRS, gridToCRS,

                        intersectionEnvelope, reprojectionNeeded);

                if (offsets.length == 2) {

                    pixelSizeX = Math.abs(offsets[0]);

                    pixelSizeY = Math.abs(offsets[1]);

                    AffineTransform tx = new AffineTransform(offsets[0], 0, 0, offsets[1], 0, 0);

                    gridToCRS = new AffineTransform2D(tx);

                } else {

                    AffineTransform tx = new AffineTransform(offsets[0], offsets[1], offsets[3],

                            offsets[4], 0, 0);

                    pixelSizeX = Math.abs(XAffineTransform.getScaleX0(tx));

                    pixelSizeY = Math.abs(XAffineTransform.getScaleY0(tx));

                    gridToCRS = new AffineTransform2D(tx);

                }

            }

            /**

             * Reproject

             */

            // adjust to have at least one pixel in the output

            if (intersectionEnvelope.getSpan(0) < Math.abs(pixelSizeX)) {

                double minX = intersectionEnvelope.getMinimum(0);

                intersectionEnvelope.setRange(0, minX, minX + pixelSizeX);

            }

            if (intersectionEnvelope.getSpan(1) < Math.abs(pixelSizeY)) {

                double minY = intersectionEnvelope.getMinimum(1);

                intersectionEnvelope.setRange(1, minY, minY + pixelSizeY);

            }

            final GridGeometry2D destinationGridGeometry = new GridGeometry2D(

                    PixelInCell.CELL_CENTER, gridToCRS, intersectionEnvelope, null);

            // before extracting the output make sure it's not too big

            WCSUtils.checkOutputLimits(wcs, destinationGridGeometry.getGridRange2D(),

                    bandSelectedCoverage.getRenderedImage().getSampleModel());

            // reproject if necessary

            boolean sameGridGeometry = bandSelectedCoverage.getGridGeometry().equals(

                    destinationGridGeometry);

            if (reprojectionNeeded || !sameGridGeometry) {

                final GridCoverage2D reprojectedCoverage = WCSUtils.resample(bandSelectedCoverage,

                        nativeCRS, targetCRS, destinationGridGeometry, interpolation);

                return new GridCoverage[] { reprojectedCoverage };

            } else {

                return new GridCoverage[] { bandSelectedCoverage };

            }

        } catch (Throwable e) {

            CoverageCleanerCallback.addCoverages(coverage);

            if (e instanceof WcsException) {

                throw (WcsException) e;

            } else {

                throw new WcsException(e);

            }

        }

    }

    private Double[] estimateOffsets(final GridCoverage2DReader reader, final GridCrsType gridCRS,

            MathTransform gridToCRS, final GeneralEnvelope intersectionEnvelope,

            boolean reprojectionNeeded) {

        Double[] offsets;

        if (!(gridToCRS instanceof AffineTransform2D) && !(gridToCRS instanceof IdentityTransform))

            throw new WcsException(

                    "Internal error, the coverage we're playing with does not have an affine transform...");

        if (!reprojectionNeeded) {

            if (gridCRS != null) {

                if (gridToCRS instanceof IdentityTransform) {

                    if (gridCRS.getGridType().equals(GridType.GT2dSimpleGrid.getXmlConstant())

                            || gridCRS.getGridType().equals(

                                    GridType.GT2dGridIn2dCrs.getXmlConstant()))

                        offsets = new Double[] { 1.0, -1.0 };

                    else

                        offsets = new Double[] { 1.0, 0.0, 0.0, 0.0, -1.0, 0.0 };

                } else {

                    AffineTransform2D affine = (AffineTransform2D) gridToCRS;

                    if (gridCRS.getGridType().equals(GridType.GT2dSimpleGrid.getXmlConstant())

                            || gridCRS.getGridType().equals(

                                    GridType.GT2dGridIn2dCrs.getXmlConstant()))

                        offsets = new Double[] { affine.getScaleX(), affine.getScaleY() };

                    else

                        offsets = new Double[] { affine.getScaleX(), affine.getShearX(),

                                affine.getShearY(), affine.getScaleY() };

                }

            } else {

                AffineTransform2D at = (AffineTransform2D) gridToCRS;

                offsets = new Double[] { at.getScaleX(), at.getShearX(), 0d, at.getShearY(),

                        at.getScaleY(), 0d };

            }

        } else {

            // the input resolution is going to be completed unrelated to the output one

            // make an estimate assuming we want to keep the output raster with roughly

            // the same size as the input one

            double teWidth = intersectionEnvelope.getSpan(0);

            double teHeight = intersectionEnvelope.getSpan(1);

            double targetRatio = teWidth / teHeight;

            GridEnvelope gr = reader.getOriginalGridRange();

            int targetRasterWidth = gr.getSpan(0);

            int targetRasterHeight = (int) Math.ceil(targetRasterWidth / targetRatio);

            double scaleX = teWidth / targetRasterWidth;

            double scaleY = -teHeight / targetRasterHeight;

            if (gridCRS == null

                    || gridCRS.getGridType().equals(GridType.GT2dSimpleGrid.getXmlConstant())

                    || gridCRS.getGridType().equals(GridType.GT2dGridIn2dCrs.getXmlConstant())) {

                offsets = new Double[] { scaleX, scaleY };

            } else {

                offsets = new Double[] { scaleX, 0.0, 0.0, 0.0, scaleY, 0.0 };

            }

        }

        return offsets;

    }

    private void checkDomainSubset(CoverageInfo meta, DomainSubsetType domainSubset, WCSInfo wcs)

            throws Exception {

        BoundingBoxType bbox = domainSubset.getBoundingBox();

        // domain subset should actually be always specified, but we try to be more lenient

        // (we should probably have a "strict cite" behavior

        if (bbox == null) {

            return;

        }

        // workaround for http://jira.codehaus.org/browse/GEOT-1710

        if ("urn:ogc:def:crs:OGC:1.3:CRS84".equals(bbox.getCrs())) {

            bbox.setCrs("EPSG:4326");

        }

        CoordinateReferenceSystem bboxCRs = CRS.decode(bbox.getCrs());

        GridCoverage2DReader reader = (GridCoverage2DReader) meta.getGridCoverageReader(null,

                WCSUtils.getReaderHints(wcs));

        Envelope gridEnvelope = reader.getOriginalEnvelope();

        GeneralEnvelope gridEnvelopeBboxCRS = null;

        if (bboxCRs instanceof GeographicCRS) {

            try {

                CoordinateOperationFactory cof = CRS.getCoordinateOperationFactory(true);

                final CoordinateOperation operation = cof.createOperation(

                        gridEnvelope.getCoordinateReferenceSystem(), bboxCRs);

                gridEnvelopeBboxCRS = CRS.transform(operation, gridEnvelope);

            } catch (Exception e) {

                // this may happen, there is nothing we can do about it, we just

                // use the back transformed envelope to be more lenient about

                // which coordinate coorections to make on the longitude axis

                // should the antimeridian style be used

            }

        }

        // check the coordinates, but make sure the case 175,-175 is handled

        // as valid for the longitude axis in a geographic coordinate system

        // see section 7.6.2 of the WCS 1.1.1 spec)

        List<Double> lower = bbox.getLowerCorner();

        List<Double> upper = bbox.getUpperCorner();

        for (int i = 0; i < lower.size(); i++) {

            if (lower.get(i) > upper.get(i)) {

                final CoordinateSystemAxis axis = bboxCRs.getCoordinateSystem().getAxis(i);

                // see if the coordinates can be fixed

                if (bboxCRs instanceof GeographicCRS && axis.getDirection() == AxisDirection.EAST) {

                    if (gridEnvelopeBboxCRS != null) {

                        // try to guess which one needs to be fixed

                        final double envMax = gridEnvelopeBboxCRS.getMaximum(i);

                        if (envMax >= lower.get(i))

                            upper.set(i,

                                    upper.get(i)

                                            + (axis.getMaximumValue() - axis.getMinimumValue()));

                        else

                            lower.set(i,

                                    lower.get(i)

                                            - (axis.getMaximumValue() - axis.getMinimumValue()));

                    } else {

                        // just fix the upper and hope...

                        upper.set(i,

                                upper.get(i) + (axis.getMaximumValue() - axis.getMinimumValue()));

                    }

                }

                // if even after the fix we're in the wrong situation, complain

                if (lower.get(i) > upper.get(i)) {

                    throw new WcsException("illegal bbox, min of dimension " + (i + 1) + ": "

                            + lower.get(i) + " is " + "greater than max of same dimension: "

                            + upper.get(i), WcsExceptionCode.InvalidParameterValue, "BoundingBox");

                }

            }

        }

    }

    /**

     * Checks that the elements of the Output part of the request do make sense by comparing them to the coverage metadata

     *

     * @param info

     * @param rangeSubset

     */

    private void checkOutput(CoverageInfo meta, OutputType output) {

        if (output == null)

            return;

        String format = output.getFormat();

        String declaredFormat = getDeclaredFormat(meta.getSupportedFormats(), format);

        if (declaredFormat == null)

            throw new WcsException("format " + format + " is not supported for this coverage",

                    InvalidParameterValue, "format");

        final GridCrsType gridCRS = output.getGridCRS();

        if (gridCRS != null) {

            // check grid base crs is valid, and eventually default it out

            String gridBaseCrs = gridCRS.getGridBaseCRS();

            if (gridBaseCrs != null) {

                // make sure the requested is among the supported ones, by

                // making a

                // code level

                // comparison (to avoid assuming epsg:xxxx and

                // http://www.opengis.net/gml/srs/epsg.xml#xxx are different

                // ones.

                // We'll also consider the urn one comparable, allowing eventual

                // axis flip on the

                // geographic crs

                String actualCRS = null;

                final String gridBaseCrsCode = extractCode(gridBaseCrs);

                for (Iterator it = meta.getResponseSRS().iterator(); it.hasNext();) {

                    final String responseCRS = (String) it.next();

                    final String code = extractCode(responseCRS);

                    if (code.equalsIgnoreCase(gridBaseCrsCode)) {

                        actualCRS = responseCRS;

                    }

                }

                if (actualCRS == null)

                    throw new WcsException("CRS " + gridBaseCrs

                            + " is not among the supported ones for coverage " + meta.getName(),

                            WcsExceptionCode.InvalidParameterValue, "GridBaseCrs");

                gridCRS.setGridBaseCRS(gridBaseCrs);

            } else {

                String code = GML2EncodingUtils.epsgCode(meta.getCRS());

                gridCRS.setGridBaseCRS("urn:x-ogc:def:crs:EPSG:" + code);

            }

            // check grid type makes sense and apply default otherwise

            String gridTypeValue = gridCRS.getGridType();

            GridType type = GridType.GT2dGridIn2dCrs;

            if (gridTypeValue != null) {

                type = null;

                for (GridType gt : GridType.values()) {

                    if (gt.getXmlConstant().equalsIgnoreCase(gridTypeValue))

                        type = gt;

                }

                if (type == null)

                    throw new WcsException("Unknown grid type " + gridTypeValue,

                            InvalidParameterValue, "GridType");

                else if (type == GridType.GT2dGridIn3dCrs)

                    throw new WcsException("Unsupported grid type " + gridTypeValue,

                            InvalidParameterValue, "GridType");

            }

            gridCRS.setGridType(type.getXmlConstant());

            // check gridcs and apply only value we know about

            String gridCS = gridCRS.getGridCS();

            if (gridCS != null) {

                if (!gridCS.equalsIgnoreCase(GridCS.GCSGrid2dSquare.getXmlConstant()))

                    throw new WcsException("Unsupported grid cs " + gridCS, InvalidParameterValue,

                            "GridCS");

            }

            gridCRS.setGridCS(GridCS.GCSGrid2dSquare.getXmlConstant());

            // check the grid origin and set defaults

            CoordinateReferenceSystem crs = null;

            try {

                crs = CRS.decode(gridCRS.getGridBaseCRS());

            } catch (Exception e) {

                throw new WcsException("Could not understand crs " + gridCRS.getGridBaseCRS(),

                        WcsExceptionCode.InvalidParameterValue, "GridBaseCRS");

            }

            if (!gridCRS.isSetGridOrigin() || gridCRS.getGridOrigin() == null) {

                // if not set, we have a default of "0 0" as a string, since I

                // cannot

                // find a way to make it default to new Double[] {0 0} I'll fix

                // it here

                Double[] origin = new Double[type.getOriginArrayLength()];

                Arrays.fill(origin, 0.0);

                gridCRS.setGridOrigin(origin);

            } else {

                Double[] gridOrigin = (Double[]) gridCRS.getGridOrigin();

                // make sure the origin dimension matches the output crs

                // dimension

                if (gridOrigin.length != type.getOriginArrayLength())

                    throw new WcsException("Grid origin size (" + gridOrigin.length

                            + ") inconsistent with grid type " + type.getXmlConstant()

                            + " that requires (" + type.getOriginArrayLength() + ")",

                            WcsExceptionCode.InvalidParameterValue, "GridOrigin");

                gridCRS.setGridOrigin(gridOrigin);

            }

            // perform same checks on the offsets

            Double[] gridOffsets = (Double[]) gridCRS.getGridOffsets();

            if (gridOffsets != null) {

                // make sure the origin dimension matches the grid type

                if (type.getOffsetArrayLength() != gridOffsets.length)

                    throw new WcsException("Invalid offsets lenght, grid type "

                            + type.getXmlConstant() + " requires " + type.getOffsetArrayLength(),

                            InvalidParameterValue, "GridOffsets");

            } else {

                gridCRS.setGridOffsets(null);

            }

        }

    }

    /**

     * Extracts only the final part of an EPSG code allowing for a specification independent comparison (that is, it removes the EPSG:, urn:xxx:,

     * http://... prefixes)

     *

     * @param srsName

     * @return

     */

    private String extractCode(String srsName) {

        if (srsName.startsWith("http://www.opengis.net/gml/srs/epsg.xml#"))

            return srsName.substring(40);

        else if (srsName.startsWith("urn:"))

            return srsName.substring(srsName.lastIndexOf(':') + 1);

        else if (srsName.startsWith("EPSG:"))

            return srsName.substring(5);

        else

            return srsName;

    }

    /**

     * Checks if the supported format string list contains the specified format, doing a case insensitive search. If found the declared output format

     * name is returned, otherwise null is returned.

     *

     * @param supportedFormats

     * @param format

     * @return

     */

    private String getDeclaredFormat(List supportedFormats, String format) {

        // supported formats may be setup using old style formats, first scan

        // the

        // configured list

        for (Iterator it = supportedFormats.iterator(); it.hasNext();) {

            String sf = (String) it.next();

            if (sf.equalsIgnoreCase(format)) {

                return sf;

            } else {

                CoverageResponseDelegate delegate = responseFactory.encoderFor(sf);

                if (delegate != null && delegate.canProduce(format))

                    return sf;

            }

        }

        return null;

    }

    /**

     * Checks that the elements of the RangeSubset part of the request do make sense by comparing them to the coverage metadata

     *

     * @param info

     * @param rangeSubset

     */

    private void checkRangeSubset(CoverageInfo info, RangeSubsetType rangeSubset) {

        // quick escape if no range subset has been specified (it's legal)

        if (rangeSubset == null)

            return;

        if (rangeSubset.getFieldSubset().size() > 1) {

            throw new WcsException("Multi field coverages are not supported yet",

                    InvalidParameterValue, "RangeSubset");

        }

        // check field identifier

        FieldSubsetType field = (FieldSubsetType) rangeSubset.getFieldSubset().get(0);

        final String fieldId = field.getIdentifier().getValue();

        if (!fieldId.equalsIgnoreCase("contents"))

            throw new WcsException("Unknown field " + fieldId, InvalidParameterValue, "RangeSubset");

        // check interpolation

        String interpolation = field.getInterpolationType();

        if (interpolation != null) {

            boolean interpolationSupported = false;

            if (interpolation.equalsIgnoreCase("nearest")) {

                interpolation = "nearest neighbor";

            } else if (interpolation.equalsIgnoreCase("cubic") || interpolation.equalsIgnoreCase("bicubic")) {

                interpolation = "bicubic";

            } else if (interpolation.equalsIgnoreCase("linear") || interpolation.equalsIgnoreCase("bilinear")) {

                interpolation = "bilinear";

            }

            for (String method : info.getInterpolationMethods()) {

                if (interpolation.equalsIgnoreCase(method)) {

                    interpolationSupported = true;

                    break;

                }

            }

            if (!interpolationSupported)

                throw new WcsException(

                        "The requested Interpolation method is not supported by this Coverage.",

                        InvalidParameterValue, "RangeSubset");

        }

        // check axis

        if (field.getAxisSubset().size() > 1) {

            throw new WcsException("Multi axis coverages are not supported yet",

                    InvalidParameterValue, "RangeSubset");

        } else if (field.getAxisSubset().size() == 0)

            return;

        AxisSubsetType axisSubset = (AxisSubsetType) field.getAxisSubset().get(0);

        final String axisId = axisSubset.getIdentifier();

        if (!axisId.equalsIgnoreCase("Bands"))

            throw new WcsException("Unknown axis " + axisId + " in field " + fieldId,

                    InvalidParameterValue, "RangeSubset");

        // prepare a support structure to quickly get the band index of a key

        // (and remember we replaced spaces with underscores in the keys to

        // avoid issues

        // with the kvp parsing of indentifiers that include spaces)

        List<CoverageDimensionInfo> dimensions = info.getDimensions();

        Set<String> dimensionMap = new HashSet<String>();

        for (int i = 0; i < dimensions.size(); i++) {

            String keyName = dimensions.get(i).getName().replace(' ', '_');

            dimensionMap.add(keyName);

        }

        // check keys

        List keys = axisSubset.getKey();

        int[] bands = new int[keys.size()];

        for (int j = 0; j < bands.length; j++) {

            final String key = (String) keys.get(j);

            String parsedKey = null;

            for (String dimensionName : dimensionMap) {

                if (dimensionName.equalsIgnoreCase(key)) {

                    parsedKey = dimensionName;

                    break;

                }

            }

            if (parsedKey == null)

                throw new WcsException("Unknown field/axis/key combination " + fieldId + "/"

                        + axisSubset.getIdentifier() + "/" + key, InvalidParameterValue,

                        "RangeSubset");

            else

                keys.set(j, parsedKey);

        }

    }

    /**

     *

     * @param date

     * @return

     */

    private static Date cvtToGmt(Date date) {

        TimeZone tz = TimeZone.getDefault();

        Date ret = new Date(date.getTime() - tz.getRawOffset());

        // if we are now in DST, back off by the delta. Note that we are checking the GMT date, this is the KEY.

        if (tz.inDaylightTime(ret)) {

            Date dstDate = new Date(ret.getTime() - tz.getDSTSavings());

            // check to make sure we have not crossed back into standard time

            // this happens when we are on the cusp of DST (7pm the day before the change for PDT)

            if (tz.inDaylightTime(dstDate)) {

                ret = dstDate;

            }

        }

        return ret;

    }

}