/* -*-c++-*- */
/* osgEarth - Geospatial SDK for OpenSceneGraph
 * Copyright 2019 Pelican Mapping
 * http://osgearth.org
 *
 * osgEarth is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 */
#ifndef OSGEARTH_SPLAT_COVERAGE_LEGEND
#define OSGEARTH_SPLAT_COVERAGE_LEGEND 1

#include "Export"
#include <osgEarth/Config>
#include <osg/Referenced>
#include <string>

namespace osgEarth { namespace Splat
{
    /**
     * Associates a specific source data coverage value to the name
     * of a splat class.
     */
    template<typename T>
    class OSGEARTHSPLAT_EXPORT CoverageValuePredicateT : public osg::Referenced
    {
    public:
        optional<T> _exactValue;
        optional<T> _minValue;
        optional<T> _maxValue;

        optional<std::string> _description;
        optional<std::string> _mappedClassName;

        bool match(const T& testValue) const
        {
            if ( _exactValue.isSetTo(testValue) )
                return true;
            if ( !_minValue.isSet() && !_maxValue.isSet() )
                return false;
            if ( _minValue.isSet() && _minValue.get() > testValue )
                return false;
            if ( _maxValue.isSet() && _maxValue.get() < testValue )
                return false;

            return true;
        }
    };

    typedef CoverageValuePredicateT<std::string> CoverageValuePredicate;


    /**
     * Legend that maps coverage values (or value predicates) to splat
     * catalog classes.
     */
    class OSGEARTHSPLAT_EXPORT SplatCoverageLegend : public osg::Referenced
    {
    public:
        SplatCoverageLegend();

    public:
        // Collection of coverage value predicated
        typedef std::vector< osg::ref_ptr<CoverageValuePredicate> > Predicates;

        /**
         * The collection of value->class mapping predicates
         */
        const Predicates& getPredicates() const { return _predicates; }

        /**
         * Whether this legend is empty.
         */
        bool empty() const { return _predicates.empty(); }

        /**
         * Looks up a precidate for the given class name, or returns NULL
         * if there isn't one.
         */
        bool getPredicatesForClass(const std::string& className, std::vector<const CoverageValuePredicate*>& output) const;

    public: // serialization

        // populate this object from a Config
        void fromConfig(const Config& conf);

        // serialize this object to a Config.
        Config getConfig() const;


    protected:

        virtual ~SplatCoverageLegend() { }

        optional<std::string> _name;
        optional<std::string> _source;

        Predicates _predicates;
    };

} } // namespace osgEarth::Splat

#endif // OSGEARTH_SPLAT_COVERAGE_LEGEND
