Mapscene.h

// Copyright eeGeo Ltd (2012-2017), All Rights Reserved

#pragma once

#include "Types.h"
#include "LatLongAltitude.h"
#include "InteriorId.h"
#include <string>

namespace Eegeo
{
    
    namespace Mapscenes
    {
        struct MapsceneSearchMenuItem
        {
        public:

            MapsceneSearchMenuItem(const std::string& name,
                const std::string& tag,
                const std::string& iconKey,
                bool skipYelpSearch)
                : name(name)
                , tag(tag)
                , iconKey(iconKey)
                , skipYelpSearch(skipYelpSearch)
            {
            }

            MapsceneSearchMenuItem()
                : name("")
                , tag("")
                , iconKey("")
                , skipYelpSearch(false)
            {

            }

            std::string name;
            std::string tag;
            std::string iconKey;
            bool skipYelpSearch;
        };

        struct MapsceneStartLocation
        {
        public:

            MapsceneStartLocation(const Space::LatLongAltitude& location,
                const std::string& interiorId,
                const int interiorFloorIndex,
                const float heading,
                const float distanceToInterest,
                const bool tryStartAtGpsLocation)
                : startLocation(location)
                , startLocationInteriorId(interiorId)
                , startLocationInteriorFloorIndex(interiorFloorIndex)
                , startLocationHeading(heading)
                , startLocationDistanceToInterest(distanceToInterest)
                , tryStartAtGpsLocation(tryStartAtGpsLocation)
            {
            }

            MapsceneStartLocation()
                : startLocation(0,0,0)
                , startLocationInteriorId("")
                , startLocationInteriorFloorIndex(0)
                , startLocationHeading(0)
                , startLocationDistanceToInterest(0)
                , tryStartAtGpsLocation(false)
            {
            }

            Space::LatLongAltitude startLocation;
            Resources::Interiors::InteriorId startLocationInteriorId;
            int startLocationInteriorFloorIndex;
            float startLocationHeading;
            float startLocationDistanceToInterest;
            bool tryStartAtGpsLocation;
        };

        struct MapsceneDataSources
        {
        public:
            MapsceneDataSources(const std::string& coverageTreeManifestUrl,
                const std::string& themeManifestUrl,
                const std::string& webCoverageTreeManifestUrl,
                const std::string& webThemeManifestUrl)
                : coverageTreeManifestUrl(coverageTreeManifestUrl)
                , themeManifestUrl(themeManifestUrl)
                , webCoverageTreeManifestUrl(webCoverageTreeManifestUrl)
                , webThemeManifestUrl(webThemeManifestUrl)
            {

            }

            MapsceneDataSources()
            : coverageTreeManifestUrl("")
            , themeManifestUrl("")
            , webCoverageTreeManifestUrl("")
            , webThemeManifestUrl("")
            {

            }

            std::string coverageTreeManifestUrl;
            std::string themeManifestUrl;
            std::string webCoverageTreeManifestUrl;
            std::string webThemeManifestUrl;
        };

        struct MapsceneSearchConfig
        {
        public:

            MapsceneSearchConfig(const std::vector<MapsceneSearchMenuItem> outdoorSearchMenuItems,
                const std::string& startUpSearchTerm,
                bool performStartUpSearch,
                bool overrideIndoorSearchMenu)
                : outdoorSearchMenuItems(outdoorSearchMenuItems)
                , startUpSearchTerm(startUpSearchTerm)
                , performStartUpSearch(performStartUpSearch)
                , overrideIndoorSearchMenu(overrideIndoorSearchMenu)
            {

            }

            MapsceneSearchConfig()
                : startUpSearchTerm("")
                , performStartUpSearch(false)
                , overrideIndoorSearchMenu(false)
            {

            }
            
            std::vector<MapsceneSearchMenuItem> outdoorSearchMenuItems;
            std::string startUpSearchTerm;
            bool performStartUpSearch;
            bool overrideIndoorSearchMenu;
        };

        struct Mapscene
        {
        public:

            Mapscene(const std::string& name,
                const std::string& shortlink,
                const std::string& apiKey,
                const MapsceneStartLocation& startLocation,
                const MapsceneDataSources& dataSources,
                const MapsceneSearchConfig& searchConfig
                )
                : name(name)
                , shortlink(shortlink)
                , apiKey(apiKey)
                , startLocation(startLocation)
                , dataSources(dataSources)
                , searchConfig(searchConfig)
            {

            }

            Mapscene()
                : name("")
                , shortlink("")
                , apiKey("")
            {

            }

            std::string name;
            std::string shortlink;
            std::string apiKey;

            MapsceneStartLocation startLocation;
            MapsceneDataSources dataSources;
            MapsceneSearchConfig searchConfig;
        };
    }
}