TransitIncidentManager.h

#pragma once
#include "NDEVR/Headers/QTModelManager.h"
#include "IOFactory/Headers/NDVFactory.h"
#include "Design/Headers/ContactInfo.h"
#include "Base/Headers/FileResource.h"
namespace NDEVR
{
    
    class TransitIncidentManager
    {
    public:
        TransitIncidentManager(QTModelManager* manager)
            : m_bus_cache_location(FileResource::PathToProgramDynamicResources().appendPath("Bus_Cache.ndv"))
            , m_driver_cache_location(FileResource::PathToProgramDynamicResources().appendPath("Driver_Cache.ndv"))
            , m_manager(manager)
        {}

        QTModelManager* manager() const
        {
            return m_manager;
        }

        void setupProject()
        {
            createAddressRoot();
            createOfficerRoot();
            createWitnessRoot();
            createPedestrainRoot();
            createVehicleRoot();
            createBussesRoot();
            createDriverRoot();
        }

        DynamicPointer<QTDesignObject> officerRoot()
        {
            return m_manager->getQTObject(officerRootID());
        }

        DynamicPointer<QTDesignObject> witnessRoot()
        {
            return m_manager->getQTObject(witnessRootID());
        }

        DynamicPointer<QTDesignObject> pedestrianRoot()
        {
            return m_manager->getQTObject(pedestrianRootID());
        }

        DynamicPointer<QTDesignObject> vehicleRoot()
        {
            return m_manager->getQTObject(vehicleRootID());
        }

        DynamicPointer<QTDesignObject> busCache()
        {
            return m_manager->getQTObject(m_bus_cache_root);
        }

        DynamicPointer<QTDesignObject> driverCache()
        {
            return m_manager->getQTObject(m_driver_cache_root);
        }

        DynamicPointer<QTDesignObject> incidentAddress()
        {
            return m_manager->getQTObject(activeAddressID());
        }

        void setActiveBus(const UUID& id)
        {
            WLock lock(m_manager->writeLock());
            Model model = m_manager->model(id);
            Model active_bus = m_manager->model(activeBusID());
            if (!active_bus.isValid())
            {
                Scene scene(_t("Active Bus"));
                scene.set<NDPC::e_translatable_name>(_t("Active Bus"));
                Model active_bus = scene.createChild();
                active_bus.set<NDPO::guid>(activeBusID());
                WLock lock = m_manager->writeLock();
                m_manager->addScene(scene);
                active_bus = scene;
            }
            active_bus.copyFrom(model, true);
            active_bus.set<NDPO::uncompressed_data>(String(id));
        }

        void setActiveDriver(const UUID& id)
        {
            WLock lock(m_manager->writeLock());
            Model model = m_manager->model(id);
            if (!m_manager->model(activeDriverID()))
            {
                Scene scene(_t("Active Driver"));
                scene.set<NDPC::e_translatable_name>(_t("Active Driver"));
                Model active_driver = scene.createChild();
                active_driver.set<NDPO::guid>(activeDriverID());
                WLock lock = m_manager->writeLock();
                m_manager->addScene(scene);
            }
            auto active_driver = m_manager->model(activeDriverID());
            active_driver.copyFrom(model, true);
            active_driver.set<NDPO::uncompressed_data>(String(id));
        }

        void saveDriverCache()
        {
            saveCache(m_driver_cache_location, m_driver_cache_root);
        }

        void saveBusCache()
        {
            saveCache(m_bus_cache_location, m_bus_cache_root);
        }

        UUID activeDriverID() const
        {
            return m_manager->activeProject().appendUUID("active_driver");
        }

        UUID activeBusID() const
        {
            return m_manager->activeProject().appendUUID("active_bus");
        }

        UUID activeAddressID() const
        {
            return m_manager->activeProject().appendUUID("active_address");
        }

        UUID witnessRootID() const
        {
            return m_manager->activeProject().appendUUID("witness_root");
        }

        UUID officerRootID() const
        {
            return m_manager->activeProject().appendUUID("officer_root");
        }

        UUID pedestrianRootID() const
        {
            return m_manager->activeProject().appendUUID("pedestrain_root");
        }

        UUID vehicleRootID() const
        {
            return m_manager->activeProject().appendUUID("involved_vehicles_root");
        }
    protected:
        void createBussesRoot()
        {
            m_bus_cache_root = readCache(m_bus_cache_location, "Bus");
        }

        void createDriverRoot()
        {
            m_driver_cache_root = readCache(m_driver_cache_location, "Driver");
        }

        UUID readCache(const File& file, const StringView& root_name)
        {
            if (file.exists())
            {
                FileRequest request(file, NDVFactory::NDVFormat());
                FactoryParameters params(request);
                params.options.center_model = false;
                params.options.tree_is_visible = false;
                params.options.application_locked = true;
                params.options.generate_trees = false;
                params.lookup = m_manager;
                NDVFactory::DefaultFactory().readFile(params);
                lib_assert(params.models.size() == 1, "Unexpected bus cache size");
                if(params.models.size() >= 1)
                    return params.models[0];
            }
            Scene root = Scene(TranslatedString(root_name));
            root.set<NDPO::tree_visible>(false);
            WLock lock = m_manager->writeLock();
            m_manager->addScene(root);
            return root.get<NDPO::guid>();
        }

        void saveCache(const File& file, const UUID& root)
        {
            FileRequest request(file, NDVFactory::NDVFormat());
            FactoryParameters params(request);
            params.lookup = m_manager;
            params.models = { root };
            NDVFactory::DefaultFactory().writeFile(params);
        }

        void createOfficerRoot()
        {
            if (!m_manager->scene(officerRootID()))
            {
                Scene third_parties(_t("Officers"));
                third_parties.set<NDPO::icon>("user+shadow+s:0.5+ox:0.5+oy:0.5+visible");
                third_parties.set<NDPO::guid>(officerRootID());
                WLock lock = m_manager->writeLock();
                m_manager->addScene(third_parties);
            }
        }

        void createWitnessRoot()
        {
            if (!m_manager->scene(witnessRootID()))
            {
                Scene third_parties(_t("Witnesses"));
                third_parties.set<NDPO::icon>("user+shadow+s:0.5+ox:0.5+oy:0.5+visible");
                third_parties.set<NDPO::guid>(witnessRootID());
                WLock lock = m_manager->writeLock();
                m_manager->addScene(third_parties);
            }
        }

        void createPedestrainRoot()
        {
            if (!m_manager->scene(pedestrianRootID()))
            {
                Scene third_parties(_t("Pedestrians"));
                third_parties.set<NDPO::icon>("user+shadow+s:0.5+ox:0.5+oy:0.5+visible");
                third_parties.set<NDPO::guid>(pedestrianRootID());
                WLock lock = m_manager->writeLock();
                m_manager->addScene(third_parties);
            }
        }

        void createVehicleRoot()
        {
            if (!m_manager->scene(vehicleRootID()))
            {
                Scene third_parties(_t("Vehicles"));
                third_parties.set<NDPO::icon>("steering_wheel+shadow+s:0.5+ox:0.5+oy:0.5+visible");
                third_parties.set<NDPO::guid>(vehicleRootID());
                WLock lock = m_manager->writeLock();
                m_manager->addScene(third_parties);
            }
        }

        void createAddressRoot()
        {
            if (!m_manager->scene(activeAddressID()))
            {
                Scene third_parties(_t("Address"));
                third_parties.set<NDPO::guid>(activeAddressID());
                PhysicalAddressModel accident_address(third_parties);
                m_manager->addModel(accident_address);
            }
        }
    protected:
        UUID m_bus_cache_root = Constant<UUID>::Invalid;    
        UUID m_driver_cache_root = Constant<UUID>::Invalid; 
        File m_bus_cache_location;                          
        File m_driver_cache_location;                       
        Buffer<UUID> m_drivers;                             
        Buffer<UUID> m_bus_routes;                          
        QTModelManager* m_manager;                          
    };
}