ScopeLogger_p.h

#pragma once

#include "ScopeLogger.h"
#include "helpers/Active.h"
#include "parameters/Scope.h"
#include "ScopeDatatypes.h"
#include "gui/LogFrame.h"

namespace scope {

class ScopeLogger::Impl {

protected:
    Active<ControllerReturnStatus> active;

    std::wstring file_path;

    bool filepath_set;

    std::wofstream userlogfile;

    log_message_type file_messages;

    log_message_type console_message;

    log_message_type logframe_message;

    gui::CLogFrame* logframe;

    std::wstring logbooktext;

    std::list<std::wstring> logbookentries;

protected:
    Impl(const Impl& i);

    Impl operator=(const Impl& i);

    ControllerReturnStatus WriteToConsole(StopCondition* const sc, const std::wstring message) {
        DBOUT(L"" << message.c_str());
        return finished;
    }

    ControllerReturnStatus WriteToLogbox(StopCondition* const sc, const std::wstring message, const log_message_type msgtype) {
        logbookentries.push_back(message+L"\r\n");

        // Get current logbook stuff from log window
        if ( logframe != nullptr )
            logbooktext = logframe->GetLogText();
        
        // Add linebreak if needed
        if ( logbooktext.length() > 2 )
            if ( logbooktext.substr(logbooktext.length()-2, 2) != L"\r\n" )
                logbooktext += L"\r\n";
        
        // Add message
        logbooktext += message+L"\r\n";
        
        // Flush to disk and log window
        FlushLogbox(sc);

        return finished;
    }

    ControllerReturnStatus FlushLogbox(StopCondition* const sc) {
        if ( logframe != nullptr )
            logframe->ReplaceLogText(logbooktext);
        if ( filepath_set ) {
            if ( !userlogfile.is_open() )
                userlogfile.open(file_path, std::ios_base::out | std::ios_base::trunc); // Trunc: overwrite
            userlogfile << logbooktext;
            userlogfile.close();
        }
        return ControllerReturnStatus::finished;
    }

public:
    Impl(const log_message_type& filem = log_all, const log_message_type& consolem = log_all, const log_message_type& logboxm = log_all)
        : file_path(L"")
        , filepath_set(false)
        , file_messages(filem)
        , console_message(consolem)
        , logframe_message(logboxm)
        , logframe(nullptr)
        , logbookentries(1, L"")
        , logbooktext(L"") {
        Log(L"Logbook started", log_info);
    }

    ~Impl() {
        if ( userlogfile.is_open() )
            userlogfile.close();
    }

    void SetFilepath(const std::wstring& _filepath = L"C:\\ScopeData") {
        if ( !filepath_set ) {
            file_path = _filepath + L"\\log_" + GetCurrentDateString() + L"_" + GetCurrentTimeString(true) + L".txt";

            userlogfile.open(file_path);
            if ( userlogfile.bad() )
                throw std::invalid_argument("Unable to open user log file\n");
            userlogfile.close();        // We only wanted it to be cleared/old overwritten, do not keep it open
    
            filepath_set = true;

            Log(L"Logfile started", log_info);
        }
    }

    void Log(const std::wstring& message, const log_message_type& msgtype) {
        SYSTEMTIME st;
        GetLocalTime(&st);
        std::wostringstream logmsg;
        logmsg << st.wHour << L":" << std::setfill(L'0') << std::setw(2) << st.wMinute << L"::" << st.wSecond << L" - ";
        logmsg << message;
        active.Send(std::bind(&Impl::WriteToConsole, this, std::placeholders::_1, logmsg.str()));
        // Console is flushed to disk 
        active.Send(std::bind(&Impl::WriteToLogbox, this, std::placeholders::_1, logmsg.str(), msgtype));
    }

    void AttachLogFrame(gui::CLogFrame* const _logframe) {
        logframe = _logframe;
        active.Send(std::bind(&Impl::FlushLogbox, this, std::placeholders::_1));
    }

    HWND GetLogFrameWindow() {
        return this->logframe->m_hWnd;
    }

    bool HasLogFrame() const {
        return logframe!=nullptr;
    }

    void GetUserLoggings() {
        if ( logframe != nullptr )
            logbooktext = logframe->GetLogText();
        active.Send(std::bind(&Impl::FlushLogbox, this, std::placeholders::_1));
    }

    void DetachLogFrame() {
        logbooktext = logframe->GetLogText();
        logframe = nullptr;
    }

    void Shutdown() {
        active.Quit();
    }
};

}