/* osgEarth - Geospatial SDK for OpenSceneGraph
* Copyright 2008-2012 Pelican Mapping
* MIT License
*/
#ifndef OSGEARTH_SPLAT_BIOME_LAYER_H
#define OSGEARTH_SPLAT_BIOME_LAYER_H

#include "Export"
#include "Biome"
#include <osgEarth/Layer>
#include <osgEarth/LayerReference>
#include <osgEarth/FeatureSource>

namespace osgEarth
{
    namespace Splat
    {
        using namespace osgEarth;

        class OSGEARTHSPLAT_EXPORT Biome2ModelAsset : public osg::Referenced
        {
        public:
            Biome2ModelAsset(const Config& conf);

            OE_OPTION(std::string, name);
            OE_OPTION(URI, uri);

            ReadResult getOrCreate(const osgDB::Options*);

            Config getConfig() const;

        protected:
            osg::ref_ptr<osg::Node> _node;
        };


        class OSGEARTHSPLAT_EXPORT Biome2 : public osg::Referenced
        {
        public:
            Biome2() { }
            Biome2(const Config& conf);

            OE_OPTION(std::string, name);
            OE_OPTION_VECTOR(osg::ref_ptr<Biome2ModelAsset>, modelAssets);

        public:
            Config getConfig() const;

        protected:
            virtual ~Biome2() { }
        };


        class OSGEARTHSPLAT_EXPORT BiomeLayer : public Layer
        {
        public:
            class OSGEARTHSPLAT_EXPORT Options : public Layer::Options
            {
            public:
                META_LayerOptions(osgEarth, Options, Layer::Options);
                OE_OPTION_VECTOR(osg::ref_ptr<Biome2>, biomes);
                OE_OPTION_LAYER(FeatureSource, controlSet);
                virtual Config getConfig() const;
            private:
                void fromConfig(const Config& conf);
            };

        public:
            META_Layer(osgEarthSplat, BiomeLayer, Options, Layer, Biomes);

            struct SearchResult
            {
                int biomeid;
                double range2;
                bool operator < (const SearchResult& rhs) const {
                    return range2 < rhs.range2;
                }
            };

            //! Returns the N nearest biomes to the input location.
            void getNearestBiomes(
                double x,
                double y,
                unsigned maxCount,
                std::set<SearchResult>& results) const;
                
            const Biome2* getBiome(int id) const;

        protected:

            virtual void init() override;

            virtual Status openImplementation() override;

            virtual Status closeImplementation() override;

        //public:

        //    virtual void addedToMap(const Map* map) override;

        //    virtual void removedFromMap(const Map* map) override;

        protected:

            FeatureSource* getControlSet() const;

            virtual ~BiomeLayer() { }

            //void* _index;

            struct ControlPoint {
                double x, y;
                int biomeid;
            };
            typedef std::vector<ControlPoint> SpatialIndex;
            SpatialIndex _index;
        };

    }
} // namespace osgEarth::Splat

#endif // OSGEARTH_SPLAT_BIOME_LAYER_H
