/*
 * Copyright 2003-2009, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Jonas Sundström, jonas@kirilla.com
 */


#include "ZipOMatic.h"

#include <Alert.h>
#include <Roster.h>
#include <StringFormat.h>
#include <TrackerAddOnAppLaunch.h>

#include "ZipOMaticMisc.h"
#include "ZipOMaticWindow.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "file:ZipOMatic.cpp"


int
main()
{
        ZipOMatic app;
        app.Run();

        return 0;
}


ZipOMatic::ZipOMatic()
        :
        BApplication(ZIPOMATIC_APP_SIG),
        fGotRefs(false),
        fInvoker(new BInvoker(new BMessage(ZIPPO_QUIT_OR_CONTINUE), NULL, this))
{
}


ZipOMatic::~ZipOMatic()
{
}


void
ZipOMatic::RefsReceived(BMessage* message)
{
        entry_ref ref;
        if (message->FindRef("refs", &ref) == B_OK) {
                _UseExistingOrCreateNewWindow(message);
                fGotRefs = true;
        } else if (!IsLaunching()) {
                PostMessage(B_SILENT_RELAUNCH);
        }
}


void
ZipOMatic::ReadyToRun()
{
        if (!fGotRefs)
                _UseExistingOrCreateNewWindow();
}


void
ZipOMatic::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case ZIPPO_WINDOW_QUIT:
                {
                        snooze(200000);
                        if (CountWindows() == 0)
                                Quit();
                        break;
                }
                case B_SILENT_RELAUNCH:
                        _SilentRelaunch();
                        break;

                case ZIPPO_QUIT_OR_CONTINUE:
                {
                        int32 button;
                        if (message->FindInt32("which", &button) == B_OK) {
                                if (button == 0) {
                                        _StopZipping();
                                } else {
                                        if (CountWindows() == 0)
                                                Quit();
                                }
                        }
                        break;
                }

                default:
                        BApplication::MessageReceived(message);
                        break;
        }
}


bool
ZipOMatic::QuitRequested(void)
{
        if (CountWindows() <= 0)
                return true;

        BWindow* window;
        ZippoWindow* zippo;
        ZippoWindow* lastFoundZippo = NULL;
        int32 zippoCount = 0;

        for (int32 i = 0;; i++) {
                window = WindowAt(i);
                if (window == NULL)
                        break;

                zippo = dynamic_cast<ZippoWindow*>(window);
                if (zippo == NULL)
                        continue;

                lastFoundZippo = zippo;

                if (zippo->Lock()) {
                        if (zippo->IsZipping())
                                zippoCount++;
                        else
                                zippo->PostMessage(B_QUIT_REQUESTED);

                        zippo->Unlock();
                }
        }

        if (zippoCount == 1) {
                // This is likely the most frequent case - a single zipper.
                // We post a message to the window so it can put up its own
                // BAlert instead of the app-wide BAlert. This avoids making
                // a difference between having pressed Commmand-W or Command-Q.
                // Closing or quitting, it doesn't matter for a single window.

                if (lastFoundZippo->Lock()) {
                        lastFoundZippo->Activate();
                        lastFoundZippo->PostMessage(B_QUIT_REQUESTED);
                        lastFoundZippo->Unlock();
                }
                return false;
        }

        if (zippoCount > 0) {
                // The multi-zipper case differs from the single-zipper case
                // in that zippers are not paused while the BAlert is up.

                static BStringFormat format(
                        B_TRANSLATE("You have {0, plural, one{# Zip-O-Matic} "
                                "other{# Zip-O-Matics}} running.\n\n"));

                BString question;

                format.Format(question, zippoCount);

                question << B_TRANSLATE("Do you want to stop them?");

                BAlert* alert = new BAlert(NULL, question.String(),
                        B_TRANSLATE("Stop them"), B_TRANSLATE("Let them continue"), NULL,
                        B_WIDTH_AS_USUAL, B_WARNING_ALERT);
                alert->Go(fInvoker);
                alert->Activate();
                        // BAlert, being modal, does not show on the current workspace
                        // if the application has no window there. Activate() triggers
                        // a switch to a workspace where it does have a window.

                        // TODO: See if AS_ACTIVATE_WINDOW should be handled differently
                        // in src/servers/app/Desktop.cpp Desktop::ActivateWindow()
                        // or if maybe BAlert should (and does not?) activate itself.

                return false;
        }

        if (CountWindows() <= 0)
                return true;

        return false;
}


void
ZipOMatic::_SilentRelaunch()
{
        _UseExistingOrCreateNewWindow();
}


void
ZipOMatic::_UseExistingOrCreateNewWindow(BMessage* message)
{
        int32 windowCount = 0;
        BWindow* bWindow;
        ZippoWindow* zWindow;
        BList list;

        while (1) {
                bWindow = WindowAt(windowCount++);
                if (bWindow == NULL)
                        break;

                zWindow = dynamic_cast<ZippoWindow*>(bWindow);
                if (zWindow == NULL)
                        continue;

                list.AddItem(zWindow);

                if (zWindow->Lock()) {
                        if (!zWindow->IsZipping()) {
                                if (message != NULL)
                                        zWindow->PostMessage(message);
                                zWindow->SetWorkspaces(B_CURRENT_WORKSPACE);
                                zWindow->Activate();
                                zWindow->Unlock();
                                return;
                        }
                        zWindow->Unlock();
                }
        }

        if (message) {
                zWindow = new ZippoWindow(list);
                zWindow->PostMessage(message);
        } else {
                zWindow = new ZippoWindow(list, true);
        }

        zWindow->Show();
}


void
ZipOMatic::_StopZipping()
{
        BWindow* window;
        ZippoWindow* zippo;
        BList list;

        for (int32 i = 0;; i++) {
                window = WindowAt(i);
                if (window == NULL)
                        break;

                zippo = dynamic_cast<ZippoWindow*>(window);
                if (zippo == NULL)
                        continue;

                list.AddItem(zippo);
        }

        for (int32 i = 0;; i++) {
                zippo = static_cast<ZippoWindow*>(list.ItemAt(i));
                if (zippo == NULL)
                        break;

                if (zippo->Lock()) {
                        if (zippo->IsZipping())
                                zippo->StopZipping();

                        zippo->PostMessage(B_QUIT_REQUESTED);
                        zippo->Unlock();
                }
        }
}