/* osgEarth
 * Copyright 2025 Pelican Mapping
 * MIT License
 */
#pragma once

#include <osgEarth/Common>
#include <osgEarth/Config>
#include <osgEarth/Status>
#include <osgEarth/PluginLoader>
#include <osgEarth/Cache>
#include <osgEarth/SceneGraphCallback>
#include <osgEarth/LayerShader>
#include <osgEarth/Revisioning>
#include <osgEarth/IOTypes>
#include <osgEarth/DateTime>
#include <osgEarth/Callbacks>
#include <osg/BoundingBox>
#include <osg/Callback>
#include <vector>

namespace osg {
    class StateSet;
}
namespace osgDB {
    class Options;
}

//! Macro to use when defining a LayerOptions class
#define META_LayerOptions(LIBRARY, MYCLASS, SUPERCLASS) \
    protected: \
        virtual void mergeConfig(const osgEarth::Config& conf) { \
            SUPERCLASS ::mergeConfig(conf); \
            fromConfig(conf); \
        } \
        using super = SUPERCLASS; \
    public: \
        OE_COMMENT("Construct empty layer options") \
        MYCLASS () : SUPERCLASS() { fromConfig(_conf); } \
        \
        OE_COMMENT("Construct layer options from serialized data") \
        MYCLASS (const osgEarth::ConfigOptions& opt) : SUPERCLASS(opt) { fromConfig(_conf); } \
        \
        osgEarth::Config& _internal() { return _conf; } \
        const osgEarth::Config& _internal() const { return _conf; }


//! Macro to use when defining a Layer class
#define META_Layer(LIBRARY, MYCLASS, OPTIONS, SUPERCLASS, SLUG) \
    private: \
        OPTIONS * _options; \
        OPTIONS   _optionsConcrete; \
        const OPTIONS * _options0; \
        const OPTIONS   _optionsConcrete0; \
        MYCLASS ( const MYCLASS& rhs, const osg::CopyOp& op ) { } \
        using super = SUPERCLASS; \
    protected: \
        OE_COMMENT("Construct a new layer with default options") \
        MYCLASS (OPTIONS* optr, const OPTIONS* optr0) : \
            SUPERCLASS (optr? optr: &_optionsConcrete, optr0? optr0 : &_optionsConcrete0), \
            _options(optr ? optr : &_optionsConcrete), \
            _options0(optr0 ? optr0 : &_optionsConcrete0) { } \
    public: \
        META_Object(LIBRARY, MYCLASS); \
        \
        OE_COMMENT("Construct a new layer with default options") \
        MYCLASS () : \
            SUPERCLASS (&_optionsConcrete, &_optionsConcrete0), \
            _options(&_optionsConcrete), \
            _options0(&_optionsConcrete0) { MYCLASS::init(); } \
        \
        OE_COMMENT("Construct a new layer with user-defined options") \
        MYCLASS (const OPTIONS& o) : \
            SUPERCLASS (&_optionsConcrete, &_optionsConcrete0), \
            _options(&_optionsConcrete), _optionsConcrete(o), \
            _options0(&_optionsConcrete0), _optionsConcrete0(o) { MYCLASS::init(); } \
        \
        OE_COMMENT("Mutable options for this layer") \
        OPTIONS& options() { return *_options; } \
        \
        OE_COMMENT("Immutable options for this layer") \
        const OPTIONS& options() const { return *_options; } \
        \
        OE_COMMENT("Immutable original (constructor) options for this layer") \
        const OPTIONS& options_original() const { return *_options0; } \
        \
        OE_COMMENT("Configuration key for this layer (e.g. for earth files)") \
        virtual const char* getConfigKey() const { return #SLUG ; }


//! Macro for defining a layer with a default Options structure
#define META_LayerNoOptions(LIBRARY, MYCLASS, SUPERCLASS, SLUG) \
    public: \
    struct Options : public SUPERCLASS::Options { \
        META_LayerOptions(LIBRARY, Options, SUPERCLASS::Options); \
    private: \
        void fromConfig(const osgEarth::Config&) { } \
    }; \
    META_Layer(LIBRARY, MYCLASS, Options, SUPERCLASS, SLUG)
    


//! Macro to use when defining a Layer class
#define META_Layer_Abstract(LIBRARY, MYCLASS, OPTIONS, SUPERCLASS) \
    private: \
        OPTIONS * _options; \
        const OPTIONS * _options0; \
        MYCLASS ( const MYCLASS& rhs, const osg::CopyOp& op ) { } \
    protected: \
        OE_COMMENT("Construct a new layer with default options") \
        MYCLASS (OPTIONS* optr, const OPTIONS* optr0) : \
            SUPERCLASS (optr, optr0), \
            _options(optr), \
            _options0(optr0) { } \
        MYCLASS () : SUPERCLASS () { } \
        using super = SUPERCLASS; \
    public: \
        OE_COMMENT("Mutable options for this layer") \
        OPTIONS& options() { return *_options; } \
        \
        OE_COMMENT("Immutable options for this layer") \
        const OPTIONS& options() const { return *_options; } \
        \
        OE_COMMENT("Immutable original (constructor) options for this layer") \
        const OPTIONS& options_original() const { return *_options0; }

//! Templated inline property implementation macro
#define OE_LAYER_PROPERTY_IMPL(CLASS, TYPE, FUNC, OPTION) \
    void CLASS ::set ## FUNC (const TYPE & value) { options(). OPTION () = value; }\
    const TYPE & CLASS ::get ## FUNC () const { return options(). OPTION ().get(); }


namespace osgEarth
{
    class GeoExtent;
    class SequenceControl;
    class TerrainEngine;
    class TerrainResources;
    class TileKey;

    //! Base class for layer property callbacks
    struct LayerCallback : public osg::Referenced
    {
        virtual void onOpen(class Layer*) { }
        virtual void onClose(class Layer*) { }
        typedef void (LayerCallback::*MethodPtr)(class Layer* layer);
    };

    /**
     * Base class for all Map layers.
     *
     * Subclass Layer to create a new layer type. Use the META_Layer macro
     * to establish the standard options framework.
     *
     * When you create a Layer, init() is called. Do all one-time construction
     * activity where.
     *
     * When you add a Layer to a Map, the follow methods are called in order:
     *
     *   setReadOptions() sets OSG options for IO activity;
     *   open() to initialize any underlying data sources;
     *   addedToMap() to signal to the layer that it is now a member of a Map.
     */
    class OSGEARTH_EXPORT Layer : public osg::Object
    {
    public:
        META_Object(osgEarth, Layer);

        /** Layer options for serialization */
        class OSGEARTH_EXPORT Options : public ConfigOptions
        {
        public:
            META_LayerOptions(osgEarth, Options, ConfigOptions);
            OE_OPTION(std::string, name);
            OE_OPTION(bool, openAutomatically, true);
            OE_OPTION(bool, terrainPatch, false);
            OE_OPTION(std::string, cacheId);
            OE_OPTION(CachePolicy, cachePolicy);
            OE_OPTION(std::string, shaderDefine);
            OE_OPTION(std::string, attribution);
            OE_OPTION(ShaderOptions, shader);
            OE_OPTION_VECTOR(ShaderOptions, shaders);
            OE_OPTION(ProxySettings, proxySettings);
            OE_OPTION(std::string, osgOptionString);
            OE_OPTION(unsigned, l2CacheSize, 0u);
            virtual Config getConfig() const;
        private:
            void fromConfig(const Config& conf);
        };

    public:
        //! Hints that a layer can set to influence the operation of
        //! the map engine
        class Hints
        {
        public:
            OE_OPTION(CachePolicy, cachePolicy);
            OE_OPTION(unsigned, L2CacheSize);
            OE_OPTION(bool, dynamic);
        };

    public:
        //! Constructs a map layer
        Layer();

        //! This layer's unique ID.
        //! This value is generated automatically at runtime and is not
        //! guaranteed to be the same from one run to the next.
        UID getUID() const { return _uid; }

        //! osgDB read options for this Layer.
        //! If you set this, do so prior to calling open().
        virtual void setReadOptions(const osgDB::Options* options);

        //! osgDB read options for this Layer.
        const osgDB::Options* getReadOptions() const;

        //! Open a layer.
        virtual Status open() final;

        //! Open a layer. Shortcut for calling setReadOptions() followed by open().
        virtual Status open(const osgDB::Options* options) final;

        //! Close this layer.
        virtual Status close();

        //! Whether the layer is open
        bool isOpen() const;

        //! Status of this layer
        const Status& getStatus() const;

        //! Serialize this layer into a Config object (if applicable)
        virtual Config getConfig() const;

        //! Whether to automatically open this layer (by calling open) when
        //! adding the layer to a Map or when opening a map containing this Layer.
        virtual void setOpenAutomatically(bool value);

        //! Whether to automatically open this layer (by calling open) when
        //! adding the layer to a Map or when opening a map containing this Layer.
        virtual bool getOpenAutomatically() const;

        //! Cacheing policy. Only set this before opening the layer or adding to a map.
        void setCachePolicy(const CachePolicy& value);
        const CachePolicy& getCachePolicy() const;

        //! Optional scene graph provided by the layer.
        //! When this layer is added to a Map, the MapNode will call this method and
        //! add the return value to its scene graph; and remove it when the Layer
        //! is removed from the Map.
        virtual osg::Node* getNode() const { return 0L; }

        //! Extent of this layer's data.
        //! This method may return GeoExtent::INVALID which means that the
        //! extent is unavailable (not necessarily that there is no data).
        virtual const GeoExtent& getExtent() const;

        //! Temporal extent of this layer's data.
        virtual DateTimeExtent getDateTimeExtent() const;

        //! Unique caching ID for this layer.
        //! Only set this before opening the layer or adding to a map.
        //! WARNING: You should be Very Careful when using this. The Layer will
        //! automatically generate a cache ID that is sufficient most of the time.
        //! Setting your own cache ID will require manual cache invalidation when
        //! you change certain properties. Use are your own risk!
        void setCacheID(const std::string& value);
        virtual std::string getCacheID() const;

        //! Callbacks that one can use to detect scene graph changes
        SceneGraphCallbacks* getSceneGraphCallbacks() const;

        //! Hints that a subclass can set to influence the engine
        const Hints& getHints() const;

        //! Options string to pass to OpenSceneGraph reader/writers
        const std::string& getOsgOptionString() const;

    public:

        //! Layer's stateset, creating it is necessary
        osg::StateSet* getOrCreateStateSet();

        //! Layer's stateset, or NULL if none exists
        osg::StateSet* getStateSet() const;

        //! Stateset that should be applied to an entire terrain traversal
        virtual osg::StateSet* getSharedStateSet(osg::NodeVisitor* nv) const { return NULL; }

        //! How (and if) to use this layer when rendering terrain tiles.
        enum RenderType
        {
            //! Layer does not draw anything (directly)
            RENDERTYPE_NONE,

            //! Layer requires a terrain rendering pass that draws terrain tiles with texturing
            RENDERTYPE_TERRAIN_SURFACE,

            //! Layer requires a terrain rendering pass that emits terrian patches or
            //! invokes a custom drawing function
            RENDERTYPE_TERRAIN_PATCH,

            //! Layer that renders its own node graph or other geometry (no terrain)
            RENDERTYPE_CUSTOM = RENDERTYPE_NONE
        };

        //! Rendering type of this layer
        RenderType getRenderType() const { return _renderType; }

        //! Rendering type of this layer
        void setRenderType(RenderType value) { _renderType = value; }

        //! Callback that modifies the layer's bounding box for a given tile key
        virtual void modifyTileBoundingBox(const TileKey& key, osg::BoundingBox& box) const;

        //! Class type name without namespace. For example if the leaf class type
        const char* getTypeName() const;

        //! Attribution to be displayed by the application
        virtual std::string getAttribution() const;

        //! Attribution to be displayed by the application
        virtual void setAttribution(const std::string& attribution);

        //! Set a serialized user property
        void setUserProperty(
            const std::string& key, 
            const std::string& value);

        //! Get a serialized user property
        template<typename T>
        inline T getUserProperty(
            const std::string& key,
            T fallback) const;

    public:

        //! Traversal callback
        class OSGEARTH_EXPORT TraversalCallback : public osg::Callback
        {
        public:
            virtual void operator()(osg::Node* node, osg::NodeVisitor* nv) const =0;
        protected:
            void traverse(osg::Node* node, osg::NodeVisitor* nv) const;
        };

        //! Callback invoked by the terrain engine on this layer before applying
        void setCullCallback(TraversalCallback* tc);
        const TraversalCallback* getCullCallback() const;

        //! Called to traverse this layer
        void apply(osg::Node* node, osg::NodeVisitor* nv) const;

        //! Called by the terrain engine during the update traversal
        virtual void update(osg::NodeVisitor& nv) { }

        //! Map will call this function when this Layer is added to a Map.
        virtual void addedToMap(const class Map*) { }

        //! Map will call this function when this Layer is removed from a Map.
        virtual void removedFromMap(const class Map*) { }

    public: // osg::Object

        void setName(const std::string& name) override;

        void resizeGLObjectBuffers(unsigned maxSize) override;

        void releaseGLObjects(osg::State* state) const override;


    public: // Public internal methods

        //! Creates a layer from serialized data - internal use
        static osg::ref_ptr<Layer> create(const ConfigOptions& options);

        //! Creates a layer from serialized data and attempt to cast it
        //! to a specific type
        template<class T>
        static osg::ref_ptr<T> create_as(const ConfigOptions& options) {
            auto layer = create(options);
            return osg::ref_ptr<T>(dynamic_cast<T*>(layer.get()));
        }

        //! Extracts config options from a DB options - internal use
        static const ConfigOptions& getConfigOptions(const osgDB::Options*);

        Callback<void(Layer*)> onOpen;
        Callback<void(Layer*)> onClose;

        //! Adds a property notification callback to this layer
        OE_DEPRECATED("Use onOpen/onClose")
        void addCallback(LayerCallback* cb);

        //! Removes a property notification callback from this layer
        OE_DEPRECATED("Use onOpen/onClose")
        void removeCallback(LayerCallback* cb);

        //! Revision number of this layer
        int getRevision() const { return (int)_revision; }

        //! Increment the revision number for this layer, which will
        //! invalidate caches.
        virtual void dirty();

        class Options;

    public: // deprecated

        OE_DEPRECATED("Use getOpenAutomatically()")
        bool getEnabled() const;

        OE_DEPRECATED("Use setOpenAutomatically()")
        void setEnabled(bool value);

    protected:

        //! Constructs a map layer by deserializing options.
        Layer(
            Layer::Options* options,
            const Layer::Options* options0);

        //! DTOR
        virtual ~Layer();

        //! post-ctor initialization, chain to subclasses.
        //! MAKE SURE you call the superclass init() if you override this!
        virtual void init();

        //! Called by open() to connect to external resources and return a status.
        //! MAKE SURE you call superclass openImplementation() if you override this!
        //! This is where you will connect to back-end data sources if
        //! appropriate. When added to a map, init() is called before open()
        //! and addedToMap() is called after open() if it succeeds.
        //! By default, returns STATUS_OK.
        virtual Status openImplementation();

        //! Called by close() to shut down the resources associated with a layer.
        virtual Status closeImplementation();

        //! Prepares the layer for rendering if necessary.
        virtual void prepareForRendering(TerrainEngine*);

        //! Sets the status for this layer - internal
        const Status& setStatus(const Status& status) const;

        //! Sets the status for this layer with a message - internal
        const Status& setStatus(const Status::Code& statusCode, const std::string& message) const;

        //! invoke layer callbacks
        OE_DEPRECATED("Use onOpen/onClose fire")
        void fireCallback(LayerCallback::MethodPtr);

        //! mutable layer hints for the subclass to optionally access
        Hints& layerHints();

    private:
        const std::string& _layerName;
        UID _uid;
        osg::ref_ptr<osg::StateSet> _stateSet;
        RenderType _renderType;
        mutable Status _status;
        osg::ref_ptr<SceneGraphCallbacks> _sceneGraphCallbacks;
        osg::ref_ptr<TraversalCallback> _traversalCallback;
        Hints _hints;
        std::atomic_int _revision = { 1 };
        std::string _runtimeCacheId;
        osg::ref_ptr<osgDB::Options> _readOptions;
        osg::ref_ptr<CacheSettings> _cacheSettings;
        std::vector<osg::ref_ptr<LayerShader> > _shaders;
        mutable Threading::ReadWriteMutex _inuse_mutex;

        //! Prepares the layer for rendering if necessary.  
        void invoke_prepareForRendering(TerrainEngine*);

    protected:
        typedef std::vector<osg::ref_ptr<LayerCallback> > CallbackVector;
        CallbackVector _callbacks;

        osgDB::Options* getMutableReadOptions() { return _readOptions.get(); }

        void bumpRevision();

        // subclass can call this to change an option that requires
        // a re-opening of the layer.
        template<typename T, typename V>
        void setOptionThatRequiresReopen(T& target, const V& value);

        // subclass can call this to change an option that requires
        // a re-opening of the layer.
        template<typename T>
        void resetOptionThatRequiresReopen(T& target);

        //! internal cache information
        CacheSettings* getCacheSettings() { return _cacheSettings.get(); }
        const CacheSettings* getCacheSettings() const { return _cacheSettings.get(); }

        //! subclass access to a mutex that serializes the 
        //! Layer open and close methods with respect to any asynchronous
        //! functions that require the layer to remain open
        Threading::ReadWriteMutex& inUseMutex() const { return _inuse_mutex; }

        //! Layers that this layer wants to add to the map
        std::vector<osg::ref_ptr<Layer>> _sublayers;

    public:

        Layer::Options& options() { return *_options; }
        const Layer::Options& options() const { return *_options; }
        const Layer::Options& options_original() const { return *_options0; }
        virtual const char* getConfigKey() const { return "layer" ; }

        //! A layer can report statistics for debugging by overriding this function
        using Stats = std::vector<std::pair<std::string, std::string>>;
        virtual Stats reportStats() const { return {}; }

    private:
        Layer::Options * _options;
        Layer::Options   _optionsConcrete;
        const Layer::Options * _options0;
        const Layer::Options   _optionsConcrete0;

        // no copying
        Layer(const Layer& rhs, const osg::CopyOp& op);

        // allow the map access to the addedToMap/removedFromMap methods
        friend class Map;
        friend class MapNode;
    };

    using LayerVector = std::vector<osg::ref_ptr<Layer>>;


    template<typename T, typename V>
    void Layer::setOptionThatRequiresReopen(T& target, const V& value) {
        if (target != value) {
            bool wasOpen = isOpen();
            if (wasOpen) close();
            target = value;
            if (wasOpen) open();
        }
    }
    template<typename T>
    void Layer::resetOptionThatRequiresReopen(T& target) {
        if (target.isSet()) {
            bool wasOpen = isOpen();
            if (wasOpen) close();
            target.unset();
            if (wasOpen) open();
        }
    }
    template<typename T>
    T Layer::getUserProperty(const std::string& key, T fallback) const {
        return options()._internal().value(key, fallback);
    }


#define REGISTER_OSGEARTH_LAYER(NAME,CLASS) \
    extern "C" void osgdb_osgearth_##NAME(void) {} \
    static osgEarth::RegisterPluginLoader< osgEarth::PluginLoader<CLASS, osgEarth::Layer> > g_proxy_##CLASS_##NAME(OE_STRINGIFY(osgearth_layer_##NAME));

#define USE_OSGEARTH_LAYER(NAME) \
    extern "C" void osgdb_osgearth_##NAME(void); \
    static osgDB::PluginFunctionProxy proxy_osgearth_layer_##NAME(OE_STRINGIFY(osgdb_osgearth_##NAME));

} // namespace osgEarth
