MapProjection.h

#pragma once

#include <mutex>
#include <Button.h>

#include "AntiAliasedDrawing.h"
#include "Cache.h"
#include "Math.h"
#include "Rose.h"
#include "Ephemeris.h"
#include "applications/Chrono/Plan13.h"
#include "SettingsNames.h"

namespace rose {

    static constexpr double GRAYLINE_COS = -0.208;      
    static constexpr double GRAYLINE_POW =  0.75;       

    enum class EphemerisFile : size_t {
        ClearSkyMoon,
        ClearSkyAll,
        CTAmateur,
        CTCube,
        CTVisual,
    };

    enum class ProjectionType {
        Mercator,
        StationMercator,
        StationAzmuthal,
    };

    enum class MapDataType : size_t {
        TerrainDay = 0,
        TerrainNight = 1,
        CountriesDay = 0x2,
        CountriesNight = 0x3,
        MapCount,
    };

    struct SatelliteMetaData {
        std::string name;
        ImageId imageId;
        bool passRiseOk{}, passSetOk{};
        DateTime riseTime{};
        DateTime setTime{};
        double elevation{}, azimuth{}, range{}, rangeRate{};

        bool operator<(const SatelliteMetaData &other) const {
            if (passRiseOk && other.passRiseOk)
                return riseTime < other.riseTime;
            else
                return setTime < other.setTime;
        }

        void setPassData(bool riseOk, bool setOk, DateTime rise, DateTime set) {
            passRiseOk = riseOk;
            passSetOk = setOk;
            riseTime = rise;
            setTime = set;
        }

        [[nodiscard]] std::tuple<bool, bool, DateTime, DateTime> getPassData() const { return std::make_tuple(passRiseOk, passSetOk, riseTime, setTime); }

        [[nodiscard]] std::string passTimeString(time_t relative = 0) const;
    };

    struct TrackedSatellite {
        SatelliteMetaData metaData; 
        Satellite satellite;        

        void predict(DateTime dateTime) {
            satellite.predict(dateTime);
        }

        void updateMetaData(Observer observer) {
            auto [elevation, azimuth, range, range_rate] = satellite.topo(observer);
            metaData.elevation = elevation;
            metaData.azimuth = azimuth;
            metaData.range = range;
            metaData.rangeRate = range_rate;
        }
    };

    class PartitionedLine : public std::vector<Position> {
    protected:
        using LineSegment = std::vector<Position>;

        using LineParts = std::vector<LineSegment>;

        LineParts mLineParts{};

    public:
        PartitionedLine() : std::vector<Position>() {}

        ~PartitionedLine() = default;

        using Predicate = std::function<bool(Position &, Position &)>;

        void partition() {
            LineSegment segment{};
            std::copy(begin(), end(), std::back_inserter(segment));
            mLineParts.emplace_back(segment);
            clear();
        }

        void partition(Predicate p) {
            mLineParts.clear();
            if (!empty()) {
                auto first = begin();
                auto last = end();
                LineSegment work{};
                work.emplace_back(*first);
                ++first;
                while (first != last) {
                    if (p(work.back(), *first)) {
                        work.emplace_back(*first);
                    } else {
                        if (work.size() > 1)
                            mLineParts.emplace_back(work);
                        work.clear();
                        work.emplace_back(*first);
                    }
                    ++first;
                }
                if (work.size() > 1)
                    mLineParts.emplace_back(work);
                work.clear();
            }
            clear();
        }

        bool draw(std::function<bool(const Position &, const Position &)> p) {
            for (const auto &segment : mLineParts) {
                Position p0 = segment.front();
                std::for_each(segment.begin()+1, segment.end(), [&p,&p0](const Position &p1){
                    if (!p(p0,p1))
                        return false;
                    p0 = p1;
                    return true;
                });
            }
            return true;
        }
    };

    class MapProjection : public Widget {
    protected:
        SignalSerialNumber mSignalSerialNumber{};
        Rose::IconFileItem mMoonIconSpec{static_cast<ImageId>(set::AppImageId::Moon), Size{0, 0}, "full_moon.png"};

        static constexpr std::array<double, 3> GrayLineCos = {-0.105, -0.208,
                                                              -0.309};   
        static constexpr double GrayLinePow = .80;      

        static constexpr std::array<set::AppImageId,5> mSatelliteIconArray{
                set::AppImageId::DotPurple, set::AppImageId::DotYellow,
                set::AppImageId::DotGreen, set::AppImageId::DotBlue, set::AppImageId::DotRed, };

        std::stack<set::AppImageId> mSatelliteIconStack{};

        bool mTerrestrialMode{};                  
        bool mSatelliteMode{};                    
        bool mCelestialMode{};                    
        bool mAnnotationMode{};                   

        std::string mSatelliteFavorite{};         

        std::future<bool> mFutureAziProj{};       
        std::future<bool> mFutureSun{};           
        std::atomic_bool mNewSurfaces{};          
        std::atomic_bool mAbortFuture{};          

        ProjectionType mProjection{ProjectionType::Mercator};   
        std::shared_ptr<WebFileCache> mMapCache{};
        ImageId mDayMapImage{};         
        ImageId mNightMapImage{};       
        GeoPosition mQth{};             
        GeoPosition mQthRad{};          
        GeoPosition mAntipode{};        
        Size mMapSize{};                
        int mSelectedSatellite{};       

        std::array<sdl::Surface,static_cast<std::size_t>(MapDataType::MapCount)> mMapSurface{};
        std::array<sdl::Surface,static_cast<std::size_t>(MapDataType::MapCount)> mAzSurface{};

        std::array<sdl::Surface,static_cast<std::size_t>(MapDataType::MapCount)/2> mMercatorTemp;
        std::array<sdl::Surface,static_cast<std::size_t>(MapDataType::MapCount)/2> mAzimuthalTemp;

        std::atomic_bool mUpdateEphemeris{false};
        std::array<std::filesystem::path, 5> mEphemerisFilePath{};      
        EphemerisFile mEphemerisFile{EphemerisFile::ClearSkyAll};       
        void updateEphemerisFile();                 
        Observer mObserver{};                       

        std::vector<TrackedSatellite> mSatelliteList{};    
        std::mutex mSatListMutex{};                 
        double mMinimumElevation{15.};              

        static std::tuple<bool, bool, double, double, double, DateTime, DateTime>
        findNextPass(const Satellite &satellite, const Observer &observer);

        std::array<sdl::Texture,2> mMercator{}; 
        std::array<sdl::Texture,2> mAzimuthal{};    

        sdl::Texture mNightAz{};        
        sdl::Texture mDayAz{};          

        std::shared_ptr<Slot<std::string>> mSettingsUpdateRx{};  

        void drawOrbitalPath(sdl::Renderer &renderer, TrackedSatellite &satellite, Position mapPos, int splitPixel);

        void drawFootprint(sdl::Renderer &renderer, TrackedSatellite &satellite, Position mapPos, int splitPixel);

        std::unique_ptr<AntiAliasedDrawing> mDrawingContext{};

        bool computeAzimuthalMaps();

        bool setForegroundBackground();

        struct MapIcon {
            ImageId imageId{RoseImageInvalid};    
            GeoPosition geo{};                    
        };

        std::array<MapIcon,2> mStationIcons{};      
        std::array<MapIcon,2> mCelestialIcons{};    

        Satellite mMoon{};                          

        void setStationIcons(GeoPosition qth) {
            mQth = qth;
            mQthRad = GeoPosition{deg2rad(qth.lat()), deg2rad(qth.lon())};
            mAntipode = antipode(mQthRad);
            mStationIcons[0].geo = mQthRad;
            mStationIcons[1].geo = mAntipode;
            mStationIcons[0].imageId = static_cast<ImageId>(set::AppImageId::RingGreen);
            mStationIcons[1].imageId = static_cast<ImageId>(set::AppImageId::RingRed);
        }

        void setMoonPhase();
        void setCelestialIcons();

        void drawMapItem(const MapIcon &mapItem, sdl::Renderer &renderer, Rectangle mapRectangle, ProjectionType projection,
                         int splitPixel);

        template<typename InputIterator>
        void drawMapItems(InputIterator first, InputIterator last, sdl::Renderer &renderer, Rectangle mapRect,
                          ProjectionType projection, int splitPixel = 0) {
            while (first != last) {
                drawMapItem(*first, renderer, mapRect, projection, splitPixel);
                ++first;
            }
        }

    public:
        MapProjection() = delete;

        ~MapProjection() override = default;

        MapProjection(std::shared_ptr<WebFileCache> mapCache, Size mapSize);

        void initializeComposite() override;

        Rectangle widgetLayout(sdl::Renderer &renderer, Rectangle available, uint layoutStage) override;

        void draw(sdl::Renderer &renderer, Rectangle parentRect) override;

        std::shared_ptr<Slot<uint32_t>> mapFileRx{};    
        std::shared_ptr<Slot<int>> secondRx{};          
        std::shared_ptr<Slot<int>> minuteRx{};          

        static GeoPosition antipode(const GeoPosition posRadians) {
            return GeoPosition{-posRadians.lat(), (posRadians.lon() < 0. ? 1. : -1.) * (M_PI - abs(posRadians.lon()))};
        }

        static GeoPosition geoPosition(int x, int y, Size mapSize) {
            double lon = (2. * M_PI * (double)x / (double)mapSize.width()) - M_PI;
            double lat = M_PI_2 - (double)y / (double)mapSize.height() * M_PI;
            return GeoPosition{lat,lon};
        }

        static Position mapPosition(GeoPosition map, Size mapSize) {
            int x = util::roundToInt((map.lon() + M_PI) / (2. * M_PI) * (double)mapSize.width());
            int y = util::roundToInt((M_PI_2 - map.lat()) / M_PI * (double)mapSize.height());
            return Position{x, y};
        }

        Position geoToMap(GeoPosition geo, ProjectionType projection, int splitPixel);

        void setMoonEphemerisFile(EphemerisFile item, const std::filesystem::path &filePath) {
            mEphemerisFilePath[static_cast<std::size_t>(item)] = filePath;
            if (item == EphemerisFile::ClearSkyMoon) {
                // If the file is the Moon ephemeris set or update the Moon TLE.
                Ephemeris ephemeris{filePath};
                mMoon.setEphemeris(ephemeris["Moon"]);
                setMoonPhase();
                setCelestialIcons();
            } else if (mEphemerisFile == item){
                // If the ephemeris in use, update the the satellite ephemeris processor.
                updateEphemerisFile();
            }
        }

        using SignalType = std::vector<TrackedSatellite>&;

        Signal<SignalType> trackedSatelliteTx{};

        std::shared_ptr<Slot<RadioBehavior::SignalType>> satelliteSelectRx{};
    };
}