#pragma once
#include <QMutex>
#include <QString>
#include <QTime>
#include <iostream>
#include <streambuf>

namespace Incart::Common
{

class ThreadLogging
{
private:
    class Membuf: public std::streambuf // получить, потому что конструктор std :: streambuf защищен
    {
        char* MEMORY;
        size_t SIZE;
    public:
        Membuf(char* p, size_t s) : MEMORY(p), SIZE(s)
        {
            clear();
        }

        void clear()
        {
            setp( MEMORY, MEMORY + SIZE); // set start end end pointers
        }

       int64_t written()
       {
           return pptr() - pbase(); // сколько байтов было записано на самом деле?
       }
    };

private:
    char m_buffer[10000];
    Membuf m_sbuf;
    std::ostream m_stream;
    QMutex m_mutex; 

public:
    ThreadLogging()
    : m_sbuf(m_buffer,sizeof (m_buffer))
    , m_stream( &m_sbuf )
    {
    }

    ~ThreadLogging() {}

    QString get()
    {
        QMutexLocker locker( &m_mutex );
        if (m_sbuf.written() <= 0)
            return "";
        m_stream << '\0';
        QString str(m_buffer);
        m_sbuf.clear();
        return str;
    }

    // заполнять в исследуемом потоке
    template<class T>
    ThreadLogging& operator<<(T t)
    {
        QMutexLocker locker(&m_mutex);
        m_stream << t << ' ';
        return *this;
    }

    ThreadLogging& operator<<(const char c)
    {
        QMutexLocker locker(&m_mutex);
        m_stream << c;
        return *this;
    }
};

} //namespace Incart::Common