/*
 * FailureManager.h
 *
 *  Created on: 8 окт. 2019 г.
 *      Author: titov
 */

#ifndef SOURCE_APPLICATION_SAFETY_FAILUREMANAGERSETUP_H_
#define SOURCE_APPLICATION_SAFETY_FAILUREMANAGERSETUP_H_

#include "../ISetupStep.hh"

#include "../../driver/safety/ITermination.hh"


#include <memory_resource>

namespace application { namespace safety {

//!Менеджер отказов. Контролирует процедуру сброса и реакции системы на отказы.
struct FailureManager : public ISetupStep {

    typedef driver::safety::ITermination Terminator;

    Terminator * terminator = nullptr;
    std::pmr::memory_resource * memory = nullptr;

    struct Links {
        Environment::Id setup_memory;               //!<Указатель на память, которая будет использованна для динамических структур данных.
        Environment::Id terminator;                 //!<Модуль реализующий реакцию системы на отказ и восстановление работы.

        Environment::Id failure_manager;            //!<Менеджер отказов.
        Environment::Id failure_registration;       //!<Интерфейс регистрации отказов.

        Environment::Id fault_log;                  //!<Журнал отказов.

        Environment::StatusId failure_stored;       //!<Признак наличия "сохраненных" отказов.
        Environment::StatusId failure_actual;       //!<Признак наличия "текущих" отказов.

        Environment::Id ack;                        //!<Действия сброса отказов.
    };

    bool input( Environment & env );
    void build( Environment & env );

    const Links & links;
    const configuration::ProcessConfig & params;

    FailureManager( const Links & links, const configuration::ProcessConfig & params ) : links(links), params(params) {}
};

}
}

#include "../../processing/failure/FailureManager.hh"
#include "../../processing/failure/FailureLogger.hh"

#include "../../systemic/StatusLazyFast.hpp"
#include "../../systemic/FunctorLazyFast.hpp"

inline bool application::safety::FailureManager::input( Environment & env ) {

    return grab( terminator, env.rholder.getShared<Terminator>( links.terminator ) )
            and grab( memory, env.rholder.getShared<std::pmr::memory_resource>( links.setup_memory ) );

}

inline void application::safety::FailureManager::build( Environment & env ) {

    Local<std::pmr::memory_resource> lmem( memory, *env.rholder.getShared<std::pmr::memory_resource>( links.setup_memory ) );

    typedef processing::failure::FailureManager FM;

    FM * fm = memories::instance_object<FM>(env.static_object_ma, *terminator, memory );

    env.rholder.share<FM>( *fm, links.failure_manager );
    env.rholder.share<processing::failure::FailureManagerInterface>( *fm, links.failure_registration );

    typedef processing::failure::FailureLogger FL;

    FL * fl = memories::instance_object<FL>(env.static_object_ma, *fm );

    systemic::ProcScheduler::ProcessParameter proc = {
        .priority = params.priority,
        .period = params.period, .phase = params.phase,
        .controlled = false
    };

    env.scheduler.registerProcess( params.processor_id, *fl,
                                   proc );

    env.rholder.share<logging::ILoggable>( *fl, links.fault_log );

    typedef systemic::detail::StatusLazyFast<FM, &FM::isFailureActual> FailureActual;
    FailureActual * failure_actual = memories::instance_object<FailureActual>( env.static_setup_ma, *fm );

    env.statuses.add( links.failure_actual, failure_actual );

    typedef systemic::detail::StatusLazyFast<FM, &FM::isFailureStored> FailureStored;
    FailureStored * failure_stored = memories::instance_object<FailureStored>( env.static_setup_ma, *fm );

    env.statuses.add( links.failure_stored, failure_stored );

    typedef systemic::detail::FunctorLazyFast<FM, void> FailureAck;

    FailureAck::Function function = &FM::acknowledge;
    FailureAck * failure_ack = memories::instance_object<FailureAck>( env.static_setup_ma, *fm, function );

    typedef systemic::IFunctor<void> Action;

    env.rholder.share< Action >( *failure_ack, links.ack );

}

#endif /* SOURCE_APPLICATION_SAFETY_FAILUREMANAGERSETUP_H_ */