DisplayController_p.h

#pragma once

#include "DisplayController.h"
#include "BaseController_p.h"
#include "helpers/SyncQueues.h"
#include "parameters/Scope.h"
#include "helpers/ScopeMultiImage.h"
#include "helpers/ScopeMultiImageResonanceSW.h"
#include "ScopeDatatypes.h"
#include "gui/ChannelFrame.h"
#include "gui/HistogramFrame.h"
#include "ScopeLogger.h"

namespace scope {

class DisplayController::Impl
    : public BaseController<1>::Impl {

protected:
    SynchronizedQueue<ScopeMessage<SCOPE_MULTIIMAGEPTR_T>>* const input_queue;
    
    ScopeLogger scope_logger;

    std::array<std::vector<gui::CChannelFrame* const>, SCOPE_NAREAS> channelframes;

    mutable std::array<std::mutex, SCOPE_NAREAS> channelframes_mutexe;

    std::array<std::vector<gui::CHistogramFrame* const>, SCOPE_NAREAS> histogramframes;

    mutable std::array<std::mutex, SCOPE_NAREAS> histogramframes_mutexe;

protected:
    Impl(const Impl& i);

    Impl operator=(const Impl& i);

    ControllerReturnStatus Run(StopCondition* const sc, const uint32_t& _area) override {
        DBOUT(L"DisplayController::Impl::Run beginning\n");
        uint32_t area = 0;
        SCOPE_MULTIIMAGEPTR_T current_frame;
        ControllerReturnStatus returnstatus(ControllerReturnStatus::none);
        std::array<uint32_t, SCOPE_NAREAS> framecounts;
        std::fill(std::begin(framecounts), std::end(framecounts), 0);
        // avoid the mutexed access to parameters later on
        DaqMode requested_mode = parameters.requested_mode();
        std::array<uint32_t, SCOPE_NAREAS> requested_frames;

        // Initialize (deferred) locks
        std::array<std::unique_lock<std::mutex>, SCOPE_NAREAS> channelframes_locks;
        std::array<std::unique_lock<std::mutex>, SCOPE_NAREAS> histogramframes_locks;
        for ( uint32_t a = 0 ; a < SCOPE_NAREAS ; a++ ) {
            requested_frames[a] =  parameters.areas[a]->daq.requested_frames();
            channelframes_locks[a] = std::unique_lock<std::mutex>(channelframes_mutexe[a],std::defer_lock);
            histogramframes_locks[a] = std::unique_lock<std::mutex>(histogramframes_mutexe[a],std::defer_lock);
        }

        // Send current run state to channel frames
        UpdateStatusInFrames(parameters.run_state());

        // Dequeue and distribute loop
        while ( !sc->IsSet() ) {
            // Dequeue
            ScopeMessage<SCOPE_MULTIIMAGEPTR_T> msg(input_queue->Dequeue());

            // If message has abort tag, break from while loop
            if ( msg.tag == ScopeMessageTag::abort ) {
                returnstatus = ControllerReturnStatus::stopped;
                break;
            }

            current_frame = msg.cargo;
            area = current_frame->Area();

            // Increase framecount if a complete frame was received
            if ( current_frame->IsCompleteFrame() && current_frame->IsCompleteAvg() ) {
                framecounts[area]++;
                DBOUT(L"DisplayController framecount area " << area << L": " << framecounts[area]);
            }

            // Distribute current_frame to attached CChannelFrames and render the stuff in CChannelFrame's Active's thread
            channelframes_locks[area].lock();
            for ( auto cframe : channelframes[area] )
                cframe->LayOverAndRender(current_frame);                    
            channelframes_locks[area].unlock();

            // Distribute current_frame to attached CHistogramFrame and calculate and render stuff in CHistogramFrame's Active's thread
            // (only for complete frames so save time)
            if ( current_frame->IsCompleteFrame() ) {
                histogramframes_locks[area].lock();
                for ( auto hframe : histogramframes[area] )
                    hframe->HistoGramAndRender(current_frame);
                histogramframes_locks[area].unlock();
            }

            // Check if in nframes mode if we have already distributed all requested frames for all areas to display
            if ( (requested_mode == DaqModeHelper::nframes)
                && (std::equal(std::begin(requested_frames), std::end(requested_frames), std::begin(framecounts))) ) {  
                // if yes we want to stop
                sc->Set(true);
                returnstatus = ControllerReturnStatus::finished;
                DBOUT(L"DisplayController::Impl::Run - all requested frames from all areas processed\n");
            }
        }

        if ( sc->IsSet() )
            returnstatus = ControllerReturnStatus(returnstatus || ControllerReturnStatus::stopped);

        UpdateStatusInFrames(RunStateHelper::Stopped);
        DBOUT(L"DisplayController::Impl::Run ended\n");
        return returnstatus;
    }

    void UpdateStatusInFrames(const RunState& _rs) {
        for ( uint32_t a = 0 ; a < SCOPE_NAREAS ; a++ ) {
            std::lock_guard<std::mutex> lockc(channelframes_mutexe[a]);
            for( auto cframe : channelframes[a] )
                cframe->UpdateStatus(_rs);
            std::lock_guard<std::mutex> lockh(histogramframes_mutexe[a]);
            for( auto hframe : histogramframes[a] )
                hframe->UpdateStatus(_rs);
        }
    }

public:
    explicit Impl(SynchronizedQueue<ScopeMessage<SCOPE_MULTIIMAGEPTR_T>>* const _iqueue, const parameters::Scope _parameters)
        : BaseController::Impl(_parameters)
        , input_queue(_iqueue) {
        DBOUT(L"DisplayController::Impl::Impl");
    }

    virtual ~Impl() {
        DBOUT(L"DisplayController::Impl::~Impl");
        StopAll();
        WaitForAll(-1);
    }

    void StopOne(const uint32_t& _a) override {
        BaseController::Impl::StopOne(_a);
        ScopeMessage<SCOPE_MULTIIMAGEPTR_T> stopmsg(ScopeMessageTag::abort, nullptr);
        input_queue->Enqueue(stopmsg);
    }

    void ResolutionChange(const parameters::Area& _ap) {
        *parameters.areas[_ap.area()] = _ap;            // Update so that we have the current resolution in here
        // Clear the queue, so we don't have frames with the (now) wrong resolution
        input_queue->Clear();
        DBOUT(L"DisplayController::Impl::ResolutionChange to " << parameters.areas[_ap.area()]->Currentframe().xres() << L" " << parameters.areas[_ap.area()]->Currentframe().yres());
    }

    void SetHistogramLimits(const uint32_t& _area, const uint32_t& _channel, const uint16_t& _lower, const uint16_t& _upper) {
        std::lock_guard<std::mutex> lock(channelframes_mutexe[_area]);
        for ( auto cframe : channelframes[_area] )
            cframe->SetHistogramLimits(_channel, _lower, _upper);
    }

    void AttachFrame(gui::CChannelFrame* const _cframe) {
        uint32_t area = _cframe->Area();
        std::lock_guard<std::mutex> lock(channelframes_mutexe[area]);
        channelframes[area].push_back(_cframe);
        _cframe->UpdateStatus(parameters.run_state());
    }

    void DetachFrame(gui::CChannelFrame* const _cframe) {
        uint32_t area = _cframe->Area();
        std::lock_guard<std::mutex> lock(channelframes_mutexe[area]);
        std::vector<gui::CChannelFrame* const>::iterator found
            = std::find_if(std::begin(channelframes[area]), std::end(channelframes[area]), [&](const gui::CChannelFrame* const f)
                { return f->m_hWnd == _cframe->m_hWnd; } );
        if ( found == std::end(channelframes[area]) )
            throw std::exception("DisplayController::Impl::DetachChannelFrame no match");
        else
            channelframes[area].erase(found);
    }

    void AttachFrame(gui::CHistogramFrame* const _hframe) {
        uint32_t area = _hframe->Area();
        std::lock_guard<std::mutex> lock(histogramframes_mutexe[area]);
        histogramframes[area].push_back(_hframe);
        _hframe->UpdateStatus(parameters.run_state());
    }

    bool HistogramAlreadyAttached(const uint32_t& _area) const {
        std::lock_guard<std::mutex> lock(histogramframes_mutexe[_area]);
        return (histogramframes[_area].size() > 0);
    }

    void DetachFrame(gui::CHistogramFrame* const  _hframe) {
        uint32_t area = _hframe->Area();
        std::lock_guard<std::mutex> lock(histogramframes_mutexe[area]);
        std::vector<gui::CHistogramFrame* const>::iterator found 
            = std::find_if(std::begin(histogramframes[area]), std::end(histogramframes[area]), [&](const gui::CHistogramFrame* const f)
                { return f->m_hWnd == _hframe->m_hWnd; } );
        if ( found == std::end(histogramframes[area]) )
            throw std::exception("DisplayController::Impl::DetachHistogramFrame no match");
        else
            histogramframes[area].erase(found);
    }

    parameters::WindowCollection GetWindowCollection() const {
        parameters::WindowCollection wndcoll;

        for ( uint32_t a = 0 ; a < SCOPE_NAREAS ; a++ ) {
            {
            std::lock_guard<std::mutex> lock(histogramframes_mutexe[a]);
            for ( const auto& h : histogramframes[a] ) {
                wndcoll.AddWindow(L"CHistogramFrame", a, h->m_hWnd);
            }
            }

            {
            std::lock_guard<std::mutex> lock(channelframes_mutexe[a]);
            for ( const auto& c : channelframes[a] ) {
                wndcoll.AddWindow(L"CChannelFrame", a, c->m_hWnd);
            }
            }
        }
        return wndcoll;
    }
};

}