/*
 * Copyright 2017 Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Brian Hill
 */


#include "TaskTimer.h"

#include <Application.h>
#include <Catalog.h>

#include "constants.h"

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "TaskTimer"

static int32 sAlertStackCount = 0;


TaskTimer::TaskTimer(const BMessenger& target, Task* owner)
        :
        BLooper(),
        fTimeoutMicroSeconds(kTimerTimeoutSeconds * 1000000),
        fTimerIsRunning(false),
        fReplyTarget(target),
        fMessageRunner(NULL),
        fTimeoutMessage(TASK_TIMEOUT),
        fTimeoutAlert(NULL),
        fOwner(owner)
{
        Run();

        // Messenger for the Message Runner to use to send its message to the timer
        fMessenger.SetTo(this);
        // Invoker for the Alerts to use to send their messages to the timer
        fTimeoutAlertInvoker.SetMessage(
                new BMessage(TIMEOUT_ALERT_BUTTON_SELECTION));
        fTimeoutAlertInvoker.SetTarget(this);
}


TaskTimer::~TaskTimer()
{
        if (fTimeoutAlert) {
                fTimeoutAlert->Lock();
                fTimeoutAlert->Quit();
        }
        if (fMessageRunner)
                fMessageRunner->SetCount(0);
}


bool
TaskTimer::QuitRequested()
{
        return true;
}


void
TaskTimer::MessageReceived(BMessage* message)
{
        switch (message->what)
        {
                case TASK_TIMEOUT:
                {
                        fMessageRunner = NULL;
                        if (fTimerIsRunning) {
                                BString text(B_TRANSLATE_COMMENT("The task for repository"
                                        " %name% is taking a long time to complete.",
                                        "Alert message.  Do not translate %name%"));
                                BString nameString("\"");
                                nameString.Append(fRepositoryName).Append("\"");
                                text.ReplaceFirst("%name%", nameString);
                                fTimeoutAlert = new BAlert("timeout", text,
                                        B_TRANSLATE_COMMENT("Keep trying", "Button label"),
                                        B_TRANSLATE_COMMENT("Cancel task", "Button label"),
                                        NULL, B_WIDTH_AS_USUAL, B_WARNING_ALERT);
                                fTimeoutAlert->SetShortcut(0, B_ESCAPE);
                                // Calculate the position to correctly stack this alert
                                BRect windowFrame = be_app->WindowAt(0)->Frame();
                                int32 stackPos = _NextAlertStackCount();
                                float xPos = windowFrame.left
                                        + windowFrame.Width()/2 + stackPos * kTimerAlertOffset;
                                float yPos = windowFrame.top
                                        + (stackPos + 1) * kTimerAlertOffset;
                                fTimeoutAlert->Go(&fTimeoutAlertInvoker);
                                xPos -= fTimeoutAlert->Frame().Width()/2;
                                        // The correct frame for the alert is not available until
                                        // after Go is called
                                fTimeoutAlert->MoveTo(xPos, yPos);
                        }
                        break;
                }
                
                case TIMEOUT_ALERT_BUTTON_SELECTION:
                {
                        fTimeoutAlert = NULL;
                        // Timeout alert was invoked by user and timer still has not
                        // been stopped
                        if (fTimerIsRunning) {
                                // find which button was pressed
                                int32 selection = -1;
                                message->FindInt32("which", &selection);
                                if (selection == 1) {
                                        BMessage reply(TASK_KILL_REQUEST);
                                        reply.AddPointer(key_taskptr, fOwner);
                                        fReplyTarget.SendMessage(&reply);
                                } else if (selection == 0) {
                                        // Create new timer
                                        fMessageRunner = new BMessageRunner(fMessenger,
                                                &fTimeoutMessage, kTimerRetrySeconds * 1000000, 1);
                                }
                        }
                        break;
                }
        }
}


void
TaskTimer::Start(const char* name)
{
        fTimerIsRunning = true;
        fRepositoryName.SetTo(name);

        // Create a message runner that will send a TASK_TIMEOUT message if the
        // timer is not stopped
        if (fMessageRunner == NULL) {
                fMessageRunner = new BMessageRunner(fMessenger, &fTimeoutMessage,
                        fTimeoutMicroSeconds, 1);
        }
        else
                fMessageRunner->SetInterval(fTimeoutMicroSeconds);
}


void
TaskTimer::Stop(const char* name)
{
        fTimerIsRunning = false;

        // Reset max timeout so we can reuse the runner at the next Start call
        if (fMessageRunner != NULL)
                fMessageRunner->SetInterval(LLONG_MAX);

        // If timeout alert is showing replace it
        if (fTimeoutAlert) {
                // Remove current alert
                BRect frame = fTimeoutAlert->Frame();
                fTimeoutAlert->Quit();
                fTimeoutAlert = NULL;

                // Display new alert that won't send a message
                BString text(B_TRANSLATE_COMMENT("Good news! The task for repository "
                        "%name% completed.", "Alert message.  Do not translate %name%"));
                BString nameString("\"");
                nameString.Append(name).Append("\"");
                text.ReplaceFirst("%name%", nameString);
                BAlert* newAlert = new BAlert("timeout", text, kOKLabel, NULL, NULL,
                        B_WIDTH_AS_USUAL, B_WARNING_ALERT);
                newAlert->SetShortcut(0, B_ESCAPE);
                newAlert->MoveTo(frame.left, frame.top);
                newAlert->Go(NULL);
        }
}


int32
TaskTimer::_NextAlertStackCount()
{
        if (sAlertStackCount > 9)
                sAlertStackCount = 0;
        return sAlertStackCount++;
}