/*
 * Copyright 2013-2014, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "ConsoleOutputView.h"

#include <new>

#include <Button.h>
#include <CheckBox.h>
#include <LayoutBuilder.h>
#include <ScrollView.h>
#include <String.h>
#include <TextView.h>

#include <AutoDeleter.h>


enum {
        MSG_CLEAR_OUTPUT        = 'clou',
        MSG_POST_OUTPUT         = 'poou'
};


static const bigtime_t kOutputWaitInterval = 10000;


// #pragma mark - ConsoleOutputView::OutputInfo


struct ConsoleOutputView::OutputInfo {
        int32   fd;
        BString text;

        OutputInfo(int32 fd, const BString& text)
                :
                fd(fd),
                text(text)
        {
        }
};


// #pragma mark - ConsoleOutputView


ConsoleOutputView::ConsoleOutputView()
        :
        BGroupView(B_VERTICAL, 0.0f),
        fStdoutEnabled(NULL),
        fStderrEnabled(NULL),
        fConsoleOutput(NULL),
        fClearButton(NULL),
        fPendingOutput(NULL),
        fWorkToDoSem(-1),
        fOutputWorker(-1)
{
        SetName("ConsoleOutput");
}


ConsoleOutputView::~ConsoleOutputView()
{
        if (fWorkToDoSem > 0)
                delete_sem(fWorkToDoSem);

        if (fOutputWorker > 0)
                wait_for_thread(fOutputWorker, NULL);

        delete fPendingOutput;
}


/*static*/ ConsoleOutputView*
ConsoleOutputView::Create()
{
        ConsoleOutputView* self = new ConsoleOutputView();

        try {
                self->_Init();
        } catch (...) {
                delete self;
                throw;
        }

        return self;
}


void
ConsoleOutputView::ConsoleOutputReceived(int32 fd, const BString& output)
{
        if (fd == 1 && fStdoutEnabled->Value() != B_CONTROL_ON)
                return;
        else if (fd == 2 && fStderrEnabled->Value() != B_CONTROL_ON)
                return;

        OutputInfo* info = new(std::nothrow) OutputInfo(fd, output);
        if (info == NULL)
                return;

        ObjectDeleter<OutputInfo> infoDeleter(info);
        if (fPendingOutput->AddItem(info)) {
                infoDeleter.Detach();
                release_sem(fWorkToDoSem);
        }
}


void
ConsoleOutputView::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case MSG_CLEAR_OUTPUT:
                {
                        fConsoleOutput->SetText("");
                        fPendingOutput->MakeEmpty();
                        break;
                }
                case MSG_POST_OUTPUT:
                {
                        OutputInfo* info = fPendingOutput->RemoveItemAt(0);
                        if (info == NULL)
                                break;

                        ObjectDeleter<OutputInfo> infoDeleter(info);
                        _HandleConsoleOutput(info);
                }
                default:
                        BGroupView::MessageReceived(message);
                        break;
        }
}


void
ConsoleOutputView::AttachedToWindow()
{
        BGroupView::AttachedToWindow();

        fStdoutEnabled->SetValue(B_CONTROL_ON);
        fStderrEnabled->SetValue(B_CONTROL_ON);
        fClearButton->SetTarget(this);
}


void
ConsoleOutputView::LoadSettings(const BMessage& settings)
{
        fStdoutEnabled->SetValue(settings.GetBool("showStdout", true)
                        ? B_CONTROL_ON : B_CONTROL_OFF);
        fStderrEnabled->SetValue(settings.GetBool("showStderr", true)
                        ? B_CONTROL_ON : B_CONTROL_OFF);
}


status_t
ConsoleOutputView::SaveSettings(BMessage& settings)
{
        bool value = fStdoutEnabled->Value() == B_CONTROL_ON;
        if (settings.AddBool("showStdout", value) != B_OK)
                return B_NO_MEMORY;

        value = fStderrEnabled->Value() == B_CONTROL_ON;
        if (settings.AddBool("showStderr", value) != B_OK)
                return B_NO_MEMORY;

        return B_OK;
}


void
ConsoleOutputView::_Init()
{
        fPendingOutput = new OutputInfoList(10);

        fWorkToDoSem = create_sem(0, "output_work_available");
        if (fWorkToDoSem < 0)
                throw std::bad_alloc();

        fOutputWorker = spawn_thread(_OutputWorker, "output worker", B_LOW_PRIORITY, this);
        if (fOutputWorker < 0)
                throw std::bad_alloc();

        resume_thread(fOutputWorker);

        BScrollView* consoleScrollView;

        BLayoutBuilder::Group<>(this, B_HORIZONTAL, 0.0f)
                .Add(consoleScrollView = new BScrollView("console scroll", NULL, 0,
                        true, true), 3.0f)
                .AddGroup(B_VERTICAL, 0.0f)
                        .SetInsets(B_USE_SMALL_SPACING)
                        .Add(fStdoutEnabled = new BCheckBox("Stdout"))
                        .Add(fStderrEnabled = new BCheckBox("Stderr"))
                        .Add(fClearButton = new BButton("Clear"))
                        .AddGlue()
                .End()
        .End();

        consoleScrollView->SetTarget(fConsoleOutput = new BTextView("Console"));

        fClearButton->SetMessage(new BMessage(MSG_CLEAR_OUTPUT));
        fConsoleOutput->MakeEditable(false);
        fConsoleOutput->SetStylable(true);
        fConsoleOutput->SetDoesUndo(false);
}


int32
ConsoleOutputView::_OutputWorker(void* arg)
{
        ConsoleOutputView* view = (ConsoleOutputView*)arg;

        for (;;) {
                status_t error = acquire_sem(view->fWorkToDoSem);
                if (error == B_INTERRUPTED)
                        continue;
                else if (error != B_OK)
                        break;

                BMessenger(view).SendMessage(MSG_POST_OUTPUT);
                snooze(kOutputWaitInterval);
        }

        return B_OK;
}


void
ConsoleOutputView::_HandleConsoleOutput(OutputInfo* info)
{
        if (info->fd == 1 && fStdoutEnabled->Value() != B_CONTROL_ON)
                return;
        else if (info->fd == 2 && fStderrEnabled->Value() != B_CONTROL_ON)
                return;

        text_run_array run;
        run.count = 1;
        run.runs[0].font = be_fixed_font;
        run.runs[0].offset = 0;
        run.runs[0].color.red = info->fd == 1 ? 0 : 192;
        run.runs[0].color.green = 0;
        run.runs[0].color.blue = 0;
        run.runs[0].color.alpha = 255;

        bool autoScroll = false;
        BScrollBar* scroller = fConsoleOutput->ScrollBar(B_VERTICAL);
        float min, max;
        scroller->GetRange(&min, &max);
        if (min == max || scroller->Value() == max)
                autoScroll = true;

        fConsoleOutput->Insert(fConsoleOutput->TextLength(), info->text,
                info->text.Length(), &run);
        if (autoScroll) {
                scroller->GetRange(&min, &max);
                fConsoleOutput->ScrollTo(0.0, max);
        }
}