/*
 * Copyright 2003-2009, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Jonas Sundström, jonas@kirilla.com
 */
 
 
#include "ZipOMaticWindow.h"
 
#include <stdio.h>
#include <stdlib.h>
 
#include <Alert.h>
#include <Application.h>
#include <Catalog.h>
#include <Directory.h>
#include <File.h>
#include <FindDirectory.h>
#include <GroupLayout.h>
#include <LayoutBuilder.h>
#include <Locale.h>
#include <Path.h>
#include <Roster.h>
#include <Screen.h>
#include <SeparatorView.h>
#include <String.h>
#include <StringFormat.h>
 
#include "ZipOMatic.h"
#include "ZipOMaticActivity.h"
#include "ZipOMaticMisc.h"
#include "ZipperThread.h"
 
 
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "file:ZipOMaticWindow.cpp"
 
 
ZippoWindow::ZippoWindow(BList windowList, bool keepOpen)
	:
	BWindow(BRect(0, 0, 0, 0), "Zip-O-Matic", B_TITLED_WINDOW,
		B_NOT_RESIZABLE	| B_AUTO_UPDATE_SIZE_LIMITS | B_NOT_ZOOMABLE),
	fWindowList(windowList),
	fThread(NULL),
	fKeepOpen(keepOpen),
	fZippingWasStopped(false),
	fFileCount(0),
	fWindowInvoker(new BInvoker(new BMessage(ZIPPO_QUIT_OR_CONTINUE), NULL,
		this))
{
	fActivityView = new Activity("activity");
	fActivityView->SetExplicitMinSize(BSize(171, 17));
 
	fArchiveNameView = new BStringView("archive_text", "");
	fArchiveNameView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
		B_ALIGN_VERTICAL_UNSET));
 
	fZipOutputView = new BStringView("output_text",
		B_TRANSLATE("Drop files here."));
	fZipOutputView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
		B_ALIGN_VERTICAL_UNSET));
 
	fStopButton = new BButton("stop", B_TRANSLATE("Stop"),
		new BMessage(B_QUIT_REQUESTED));
	fStopButton->SetEnabled(false);
	fStopButton->SetExplicitAlignment(BAlignment(B_ALIGN_RIGHT,
		B_ALIGN_VERTICAL_UNSET));
 
	BSeparatorView* separator = new BSeparatorView(B_HORIZONTAL);
 
	BLayoutBuilder::Group<>(this)
		.AddGroup(B_VERTICAL, 10)
			.Add(fActivityView)
			.Add(fArchiveNameView)
			.Add(fZipOutputView)
			.Add(separator)
			.Add(fStopButton)
			.SetInsets(14, 14, 14, 14)
			.End()
		.End();
 
	_FindBestPlacement();
}
 
 
ZippoWindow::~ZippoWindow()
{
	delete fWindowInvoker;
}
 
 
void
ZippoWindow::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case B_REFS_RECEIVED:
		case B_SIMPLE_DATA:
			if (IsZipping()) {
				message->what = B_REFS_RECEIVED;
				be_app_messenger.SendMessage(message);
			} else {
				_StartZipping(message);
			}
			break;
 
		case ZIPPO_THREAD_EXIT:
			fThread = NULL;
			fActivityView->Stop();
			fStopButton->SetEnabled(false);
			fArchiveNameView->SetText(" ");
			if (fZippingWasStopped)
				fZipOutputView->SetText(B_TRANSLATE("Stopped"));
			else
				fZipOutputView->SetText(B_TRANSLATE("Archive created OK"));
 
			_CloseWindowOrKeepOpen();
			break;
 
		case ZIPPO_THREAD_EXIT_ERROR:
			// TODO: figure out why this case does not happen when it should
			fThread = NULL;
			fActivityView->Stop();
			fStopButton->SetEnabled(false);
			fArchiveNameView->SetText("");
			fZipOutputView->SetText(B_TRANSLATE("Error creating archive"));
			break;
 
		case ZIPPO_TASK_DESCRIPTION:
		{
			BString filename;
			if (message->FindString("archive_filename", &filename) == B_OK) {
				fArchiveName = filename;
				BString temp(B_TRANSLATE("Creating archive: %s"));
				temp.ReplaceFirst("%s", filename.String());
				fArchiveNameView->SetText(temp.String());
			}
			break;
		}
 
		case ZIPPO_LINE_OF_STDOUT:
		{
			BString string;
			if (message->FindString("zip_output", &string) == B_OK) {
				if (string.FindFirst("Adding: ") == 0) {
 
					// This is a workaround for the current window resizing
					// behavior as the window resizes for each line of output.
					// Instead of showing the true output of /bin/zip
					// we display a file count and whether the archive is
					// being created (added to) or if we're updating an
					// already existing archive.
 
					static BStringFormat format(B_TRANSLATE("{0, plural, "
						"one{# file added.} other{# files added.}}"));
					BString output;
					format.Format(output, fFileCount);
 
					fFileCount++;
 
					fZipOutputView->SetText(output.String());
				} else {
					fZipOutputView->SetText(string.String());
				}
			}
			break;
		}
 
		case ZIPPO_QUIT_OR_CONTINUE:
		{
			int32 which_button = -1;
			if (message->FindInt32("which", &which_button) == B_OK) {
				if (which_button == 0) {
					StopZipping();
				} else {
					if (fThread != NULL)
						fThread->ResumeExternalZip();
 
					fActivityView->Start();
				}
			}
			break;
		}
 
		default:
			BWindow::MessageReceived(message);
			break;
	}
}
 
 
bool
ZippoWindow::QuitRequested()
{
	if (!IsZipping()) {
		BMessage message(ZIPPO_WINDOW_QUIT);
		message.AddRect("frame", Frame());
		be_app_messenger.SendMessage(&message);
		return true;
	} else {
		fThread->SuspendExternalZip();
		fActivityView->Pause();
 
		BString message;
		message << B_TRANSLATE("Are you sure you want to stop creating this "
			"archive?");
		message << "\n\n";
		message << B_TRANSLATE("Filename: %s");
		message << "\n";
		message.ReplaceFirst("%s", fArchiveName.String());
 
		BAlert* alert = new BAlert(NULL, message.String(), B_TRANSLATE("Stop"),
			B_TRANSLATE("Continue"), NULL, B_WIDTH_AS_USUAL, B_WARNING_ALERT);
		alert->Go(fWindowInvoker);
 
		return false;
	}
}
 
 
void
ZippoWindow::_StartZipping(BMessage* message)
{
	fStopButton->SetEnabled(true);
	fActivityView->Start();
	fFileCount = 0;
 
	fThread = new ZipperThread(message, this);
	fThread->Start();
 
	fZippingWasStopped = false;
}
 
 
void
ZippoWindow::StopZipping()
{
	fZippingWasStopped = true;
 
	fStopButton->SetEnabled(false);
	fActivityView->Stop();
 
	fThread->InterruptExternalZip();
	fThread->Quit();
 
	status_t status = B_OK;
	fThread->WaitForThread(&status);
	fThread = NULL;
 
	fArchiveNameView->SetText(" ");
	fZipOutputView->SetText(B_TRANSLATE("Stopped"));
 
	_CloseWindowOrKeepOpen();
}
 
 
bool
ZippoWindow::IsZipping()
{
	if (fThread == NULL)
		return false;
	else
		return true;
}
 
 
void
ZippoWindow::_CloseWindowOrKeepOpen()
{
	if (!fKeepOpen)
		PostMessage(B_QUIT_REQUESTED);
}
 
 
void
ZippoWindow::_FindBestPlacement()
{
	CenterOnScreen();
 
	BScreen screen;
	BRect centeredRect = Frame();
	BRect tryRect = centeredRect;
	BList tryRectList;
 
	if (!screen.Frame().Contains(centeredRect))
		return;
 
	// build a list of possible locations
	tryRectList.AddItem(new BRect(centeredRect));
 
	// up and left
	direction primaryDirection = up;
	while (true) {
		_OffsetRect(&tryRect, primaryDirection);
 
		if (!screen.Frame().Contains(tryRect))
			_OffscreenBounceBack(&tryRect, &primaryDirection, left);
 
		if (!screen.Frame().Contains(tryRect))
			break;
 
		tryRectList.AddItem(new BRect(tryRect));
	}
 
	// down and right
	primaryDirection = down;
	tryRect = centeredRect;
	while (true) {
		_OffsetRect(&tryRect, primaryDirection);
 
		if (!screen.Frame().Contains(tryRect))
			_OffscreenBounceBack(&tryRect, &primaryDirection, right);
 
		if (!screen.Frame().Contains(tryRect))
			break;
 
		tryRectList.AddItem(new BRect(tryRect));
	}
 
	// remove rects that overlap an existing window
	for (int32 i = 0;; i++) {
		BWindow* win = static_cast<BWindow*>(fWindowList.ItemAt(i));
		if (win == NULL)
			break;
 
		ZippoWindow* window = dynamic_cast<ZippoWindow*>(win);
		if (window == NULL)
			continue;
 
		if (window == this)
			continue;
 
		if (window->Lock()) {
			BRect frame = window->Frame();
			for (int32 m = 0;; m++) {
				BRect* rect = static_cast<BRect*>(tryRectList.ItemAt(m));
				if (rect == NULL)
					break;
 
				if (frame.Intersects(*rect)) {
					tryRectList.RemoveItem(m);
					delete rect;
					m--;
				}
			}
			window->Unlock();
		}
	}
 
	// find nearest rect
	bool gotRect = false;
	BRect nearestRect(0, 0, 0, 0);
 
	while (true) {
		BRect* rect = static_cast<BRect*>(tryRectList.RemoveItem((int32)0));
		if (rect == NULL)
			break;
 
		nearestRect = _NearestRect(centeredRect, nearestRect, *rect);
		gotRect = true;
		delete rect;
	}
 
	if (gotRect)
		MoveTo(nearestRect.LeftTop());
}
 
 
void
ZippoWindow::_OffsetRect(BRect* rect, direction whereTo)
{
	float width = rect->Width();
	float height = rect->Height();
 
	switch (whereTo) {
		case up:
			rect->OffsetBy(0, -(height * 1.5));
			break;
 
		case down:
			rect->OffsetBy(0, height * 1.5);
			break;
 
		case left:
			rect->OffsetBy(-(width * 1.5), 0);
			break;
 
		case right:
			rect->OffsetBy(width * 1.5, 0);
			break;
	}
}
 
 
void
ZippoWindow::_OffscreenBounceBack(BRect* rect, direction* primaryDirection,
	direction secondaryDirection)
{
	if (*primaryDirection == up) {
		*primaryDirection = down;
	} else {
		*primaryDirection = up;
	}
 
	_OffsetRect(rect, *primaryDirection);
	_OffsetRect(rect, secondaryDirection);
}
 
 
BRect
ZippoWindow::_NearestRect(BRect goalRect, BRect a, BRect b)
{
	double aSum = fabs(goalRect.left - a.left) + fabs(goalRect.top - a.top);
	double bSum = fabs(goalRect.left - b.left) + fabs(goalRect.top - b.top);
 
	if (aSum < bSum)
		return a;
	else
		return b;
}