MercatorImageManager.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/SoftwareService.h>
#include <NDEVR/Bounds.h>
#include <NDEVR/String.h>
#include <NDEVR/UUID.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/RGBColor.h>
#include <NDEVR/LogPtr.h>
namespace NDEVR
{
    class InfoPipe;
    enum class AerialImageMode
    {
          e_google_satellite    
        , e_google_road         
        , e_google_terrain      
        , e_google_hybrid       
        , e_open_maps           
        , e_aerial_image_mode_size  
    };

    enum class ArialFeatureList
    {
          e_all = 0                 
        , e_administrative          
        , e_administrative_country  
        , e_administrative_land_parcel  
        , e_administrative_locality 
        , e_administrative_neighborhood 
        , e_administrative_province 
        , e_landscape               
        , e_landscape_man_made      
        , e_landscape_natural       
        , e_poi                     
        , e_poi_attraction          
        , e_poi_business            
        , e_poi_government          
        , e_poi_medical             
        , e_poi_park                
        , e_poi_place_of_worship    
        , e_poi_school              
        , e_poi_sports_complex      
        , e_road                    
        , e_road_arterial           
        , e_road_highway            
        , e_road_local              
        , e_transit                 
        , e_transit_line            
        , e_transit_station         
        , e_water                   
        , e_feature_list_size       
    };

    struct ArialColorTheme
    {
        ArialColorTheme() {};

        static RGBColor DefaultColor(ArialFeatureList item);
 
        RGBColor pen = Constant<RGBColor>::Invalid;     
        RGBColor brush = Constant<RGBColor>::Invalid;   
        bool is_on = true;                              
 
    };

    struct NDEVR_DESIGN_API WebMercatorTile
    {
        enum class DPI : uint04
        {
              e_low = 1     
            , e_high = 2    
            , e_auto        
        };

        enum class Resolution : uint04
        {
            e_low_256 = 1,  
            e_high_512 = 2, 
        };

        WebMercatorTile() {};

        WebMercatorTile(uint04 x, uint04 y, uint04 zoom, Resolution resolution, DPI dpi, bool include_labels);

        UUID getUUID(UUID parent_id) const;

        static uint04 convertResolutionToPixels(Resolution resolution);
 
        String language;                        
        Vector<2, uint04> tile = Vector<2, uint04>(0U); 
        uint04 zoom = 0;                        
        Resolution resolution = Resolution::e_low_256;  
        DPI dpi = DPI::e_low;                   
 
 
    };

    struct MercatorImage
    {
        UUID request_id;                        
        bool success = false;                   
        void* raw_image;                        
        String image_id;                        
        Bounds<2, fltp08> wgs_84_bounds;        

        Vector<2, fltp08> pixelToLatLon(Vector<2, uint04> pixel) const;
 
    };
 
    struct MercatorImageRequest;

    class NDEVR_DESIGN_API WebMercatorTileService
    {
    public:
        virtual ~WebMercatorTileService() = default;

        virtual String getUrl(WebMercatorTile tile, const MercatorImageRequest& request) const = 0;

        virtual UUID getUUID(WebMercatorTile tile, const MercatorImageRequest& request) const = 0;

        virtual Buffer<WebMercatorTile::Resolution> getSupportedResolutions() const = 0;

        virtual Buffer<WebMercatorTile::DPI> getSupportedDPIs() const = 0;

        WebMercatorTileService() = default;
        WebMercatorTileService(const WebMercatorTileService& other) = default;
        WebMercatorTileService(WebMercatorTileService&& other) = default;
        WebMercatorTileService& operator=(const WebMercatorTileService& other) = default;
        WebMercatorTileService& operator=(WebMercatorTileService&& other) = default;
    };

    struct NDEVR_DESIGN_API MercatorImageRequest
    {
        MercatorImageRequest()
        {}

        MercatorImageRequest(const ConstPointer<WebMercatorTileService>& service, Bounds<2, fltp08> bounds, Vector<2, uint04> size, WebMercatorTile::DPI dpi = WebMercatorTile::DPI::e_auto);

        void setBrushToDefault();

        UUID getUUID() const;
 
        String generated_image;                 
        ConstPointer<WebMercatorTileService> service = nullptr; 

        WebMercatorTile::Resolution getResolution() const;

        fltp08 getScaleFactor() const;

        WebMercatorTile::DPI getDPI() const;
    public:
        ArialColorTheme color_theme[cast<uint04>(ArialFeatureList::e_feature_list_size)];   
        Bounds<2, fltp08> bounds_wgs84;     
        Vector<2, uint04> size;             
        WebMercatorTile::DPI dpi = WebMercatorTile::DPI::e_auto;    
        UUID request_id;                    
        LogPtr log;                         
        bool include_labels = false;        
    };

    struct NDEVR_DESIGN_API AerialImageRequest
    {
        AerialImageRequest()
            : request_id(UUID::CreateUUID())
        { }

        MercatorImageRequest convertToWebRequest(const DynamicPointer<WebMercatorTileService>& service) const;
 
        UUID request_id;                        
        AerialImageMode image_mode = AerialImageMode::e_google_road;    
        UUID projection_id = Constant<UUID>::Invalid;   
        Bounds<2, fltp08> bounds = Constant<Bounds<2, fltp08>>::Invalid;    
        Vector<2, uint04> pixel_size = Constant<Vector<2, uint04>>::Invalid;    
        LogPtr log;                             
        std::function<void(const MercatorImage& generated_image)> finished_callback;    
    };
 
    class MercatorProcessThread;

    class NDEVR_DESIGN_API MercatorImageManager : public SoftwareService
    {
    public:
        MercatorImageManager();

        virtual bool postRequest(const MercatorImageRequest& request, std::function<void(const MercatorImage&)> finished_callback) = 0;

        virtual bool postRequest(const AerialImageRequest& request);

        virtual void setDevicePixelRatio(fltp08) {};

        [[nodiscard]] static MercatorImageManager* PrimaryManager() { return s_manager; }

        [[nodiscard]] virtual DynamicPointer<WebMercatorTileService> defaultService(AerialImageMode mode) const = 0;
    protected:
        static void SetPrimaryManager(MercatorImageManager* manager);
    protected:
        static MercatorImageManager* s_manager; 
    };
 
    template class NDEVR_DESIGN_API StringStream<AerialImageMode>;
}