/* Copyright (C) 2017 by Bundesanstalt für Gewässerkunde
 * Software engineering by
 *  Björnsen Beratende Ingenieure GmbH
 *  Dr. Schumacher Ingenieurbüro für Wasser und Umwelt
 *
 * This file is Free Software under the GNU AGPL (>=v3)
 * and comes with ABSOLUTELY NO WARRANTY! Check out the
 * documentation coming with Dive4Elements River for details.
 */

package org.dive4elements.river.artifacts.sinfo.tkhcalculation;

import java.util.List;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.TreeMap;

import org.apache.commons.lang.math.DoubleRange;
import org.apache.commons.math.ArgumentOutsideDomainException;
import org.dive4elements.river.backend.SessionHolder;
import org.dive4elements.river.model.River;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.type.StandardBasicTypes;


/**
 * @author Matthias Schäfer
 */
final class SoilKindKmValueFinder {

    /***** FIELDS *****/

    // private static Logger log = Logger.getLogger(SoilKindKmValueFinder.class);

    /**
     * Query selecting the bed mobility attribute for a range of stations of a river
     */
    private static final String SQL_BED_MOBILITY = "SELECT bmv.station, bmv.moving"
            + " FROM bed_mobility bm INNER JOIN bed_mobility_values bmv ON bm.id = bmv.bed_mobility_id"
            + " WHERE (bm.river_id=:river_id) AND (bmv.station BETWEEN (:fromkm-0.0001) AND (:tokm+0.0001))"
            + " ORDER BY bmv.station ASC";

    private final NavigableMap<Double, SoilKind> kmMobility;


    /***** CONSTRUCTORS *****/

    private SoilKindKmValueFinder() {
        /* only instantiate me via static constructor */
        this.kmMobility = null;
    }

    private SoilKindKmValueFinder(final List<Object[]> queryRows) {
        this.kmMobility = new TreeMap<>();
        for (int i = 0; i <= queryRows.size() - 1; i++) {
            this.kmMobility.put(Double.valueOf((double) queryRows.get(i)[0]), (((int) queryRows.get(i)[1]) == 1) ? SoilKind.mobil : SoilKind.starr);
        }
    }

    /***** METHODS *****/

    /**
     * Loads the range of the river's kms with their soil kind.
     *
     * @return Whether the load has been successful
     */
    public static SoilKindKmValueFinder loadValues(final River river, final DoubleRange kmRange) {
        final Session session = SessionHolder.HOLDER.get();
        final SQLQuery sqlQuery = session.createSQLQuery(SQL_BED_MOBILITY).addScalar("station", StandardBasicTypes.DOUBLE)
                .addScalar("moving", StandardBasicTypes.INTEGER);
        sqlQuery.setInteger("river_id", river.getId().intValue());
        sqlQuery.setDouble("fromkm", kmRange.getMinimumDouble());
        sqlQuery.setDouble("tokm", kmRange.getMaximumDouble());
        final List<Object[]> rows = sqlQuery.list();
        if (rows.size() >= 1)
            return new SoilKindKmValueFinder(rows);
        else
            return null;
    }

    /***** METHODS *****/

    /**
     * Searches a km with its soil kind
     */
    public SoilKind findSoilKind(final double km) throws ArgumentOutsideDomainException {
        if ((this.kmMobility == null) || this.kmMobility.isEmpty())
            throw new ArgumentOutsideDomainException(km, Double.NaN, Double.NaN);
        else if (this.kmMobility.containsKey(Double.valueOf(km)))
            return this.kmMobility.get(Double.valueOf(km));
        else {
            // FIXME: Assert minimum distance between neighbouring stations and candidate km?
            final Entry<Double, SoilKind> streamUp = this.kmMobility.floorEntry(Double.valueOf(km));
            if (streamUp == null)
                throw new ArgumentOutsideDomainException(km, Double.NaN, Double.NaN);
            else {
                // Return the soil kind of the neighbouring station with the shorter distance to the candidate.
                final Entry<Double, SoilKind> streamDown = this.kmMobility.ceilingEntry(Double.valueOf(km));
                if (streamDown == null)
                    return streamUp.getValue();
                else if ((streamUp.getKey().doubleValue() + streamDown.getKey().doubleValue()) / 2 <= km)
                    return streamUp.getValue();
                else
                    return streamDown.getValue();
            }
        }
    }
}