/*
 * Copyright 2007-2014 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus, superstippi@gmx.de
 */


#include "SpiderSaver.h"

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Bitmap.h>
#include <Catalog.h>
#include <Message.h>

#include "Polygon.h"
#include "PolygonQueue.h"
#include "SpiderView.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Screensaver Spider"


//	#pragma mark - Instantiation function


extern "C" _EXPORT BScreenSaver*
instantiate_screen_saver(BMessage* message, image_id image)
{
	return new SpiderSaver(message, image);
}


//	#pragma mark - SpiderSaver


SpiderSaver::SpiderSaver(BMessage* message, image_id id)
	:
	BScreenSaver(message, id),
	fBackBitmap(NULL),
	fBackView(NULL),
	fQueues(new PolygonQueue*[MAX_QUEUE_NUMBER]),
	fQueueNumber(20),
	fMaxPolyPoints(MAX_POLY_POINTS),
	fMaxQueueDepth(MAX_QUEUE_DEPTH),
	fColor(RED),
	fPreview(false)
{
	for (int32 i = 0; i < MAX_QUEUE_NUMBER; i++)
		fQueues[i] = NULL;

	if (message != NULL) {
		int32 value;
		if (message->FindInt32("queue number", &value) == B_OK)
			fQueueNumber = value;

		if (message->FindInt32("poly points", &value) == B_OK)
			fMaxPolyPoints = value;

		if (message->FindInt32("queue depth", &value) == B_OK)
			fMaxQueueDepth = value;

		if (message->FindInt32("color", &value) == B_OK)
			fColor = value;
	}

	srand48((long int)system_time());
}


SpiderSaver::~SpiderSaver()
{
	_Cleanup();
	delete[] fQueues;
}


void
SpiderSaver::StartConfig(BView* view)
{
	SpiderView* configView = new SpiderView(view->Bounds(), this,
		fQueueNumber, fMaxPolyPoints, fMaxQueueDepth, fColor);
	view->AddChild(configView);
}


status_t
SpiderSaver::StartSaver(BView* view, bool preview)
{
	SetTickSize(50000);

	fPreview = preview;
	fBounds = view->Bounds();
	_Init(fBounds);

	return B_OK;
}


void
SpiderSaver::StopSaver()
{
	_Cleanup();
}


void
SpiderSaver::Draw(BView* view, int32 frame)
{
	fLocker.Lock();
	for (uint32 i = 0; i < fQueueNumber; i++) {
		if (fQueues[i])
			fQueues[i]->Step();
	}
	if (fBackView) {
		if (fBackBitmap->Lock()) {
			_DrawInto(fBackView);
			fBackView->Sync();
			fBackBitmap->Unlock();
		}
		view->DrawBitmap(fBackBitmap, BPoint(0.0, 0.0));
	}
	fLocker.Unlock();
}


status_t
SpiderSaver::SaveState(BMessage* into) const
{
	if (into != NULL) {
		into->AddInt32("queue number", (int32)fQueueNumber);
		into->AddInt32("poly points", (int32)fMaxPolyPoints);
		into->AddInt32("queue depth", (int32)fMaxQueueDepth);
		into->AddInt32("color", (int32)fColor);

		return B_OK;
	}

	return B_BAD_VALUE;
}


void
SpiderSaver::SetQueueNumber(uint32 number)
{
	fLocker.Lock();
	_Cleanup();
	fQueueNumber = number;
	_Init(fBounds);
	fLocker.Unlock();
}


void
SpiderSaver::SetQueueDepth(uint32 maxDepth)
{
	fLocker.Lock();
	_Cleanup();
	fMaxQueueDepth = maxDepth;
	_Init(fBounds);
	fLocker.Unlock();
}


void
SpiderSaver::SetPolyPoints(uint32 maxPoints)
{
	fLocker.Lock();
	_Cleanup();
	fMaxPolyPoints = maxPoints;
	_Init(fBounds);
	fLocker.Unlock();
}


void
SpiderSaver::SetColor(uint32 color)
{
	fLocker.Lock();
	_Cleanup();
	fColor = color;
	_Init(fBounds);
	fLocker.Unlock();
}


//	#pragma mark - SpiderSaver private methods


void
SpiderSaver::_Init(BRect bounds)
{
	_AllocBackBitmap(bounds.Width(), bounds.Height());
	uint32 minPoints = fMaxPolyPoints / 2;
	uint32 maxPoints = fMaxPolyPoints;
	uint32 minQueueDepth = fMaxQueueDepth / 2;
	uint32 maxQueueDepth = fMaxQueueDepth;

	if (fPreview) {
		minQueueDepth /= 4;
		maxQueueDepth /= 4;
	}

	for (uint32 i = 0; i < fQueueNumber; i++) {
		fQueues[i] = new PolygonQueue(new Polygon(bounds,
			minPoints + lrand48() % (maxPoints - minPoints)),
			minQueueDepth + lrand48() % (maxQueueDepth - minQueueDepth));
	}
}


void
SpiderSaver::_Cleanup()
{
	_FreeBackBitmap();
	for (int32 i = 0; i < MAX_QUEUE_NUMBER; i++) {
		delete fQueues[i];
		fQueues[i] = NULL;
	}
}


void
SpiderSaver::_AllocBackBitmap(float width, float height)
{
	// sanity check
	if (width <= 0.0 || height <= 0.0)
		return;

	BRect b(0.0, 0.0, width, height);
	fBackBitmap = new(std::nothrow) BBitmap(b, B_RGB32, true);
	if (!fBackBitmap)
		return;

	if (fBackBitmap->IsValid()) {
		fBackView = new(std::nothrow) BView(b, 0, B_FOLLOW_NONE, B_WILL_DRAW);
		if (fBackView == NULL) {
			_FreeBackBitmap();
			fprintf(stderr,
				"SpiderSaver::_AllocBackBitmap(): view allocation failed\n");
			return;
		}
		fBackBitmap->AddChild(fBackView);
		memset(fBackBitmap->Bits(), 0, fBackBitmap->BitsLength());
	} else {
		_FreeBackBitmap();
		fprintf(stderr, "SpiderSaver::_AllocBackBitmap(): bitmap invalid\n");
	}
}


void
SpiderSaver::_FreeBackBitmap()
{
	if (fBackBitmap) {
		delete fBackBitmap;
		fBackBitmap = NULL;
		fBackView = NULL;
	}
}


void
SpiderSaver::_DrawInto(BView* view)
{
	for (uint32 i = 0; i < fQueueNumber; i++) {
		switch (fColor) {
			case GREEN:
				view->SetHighColor(1, 2, 1, 255);
				break;

			case BLUE:
				view->SetHighColor(1, 1, 2, 255);
				break;

			case YELLOW:
				view->SetHighColor(2, 2, 1, 255);
				break;

			case PURPLE:
				view->SetHighColor(2, 1, 2, 255);
				break;

			case CYAN:
				view->SetHighColor(1, 2, 2, 255);
				break;

			case GRAY:
				view->SetHighColor(2, 2, 2, 255);
				break;

			case RED:
			default:
				view->SetHighColor(2, 1, 1, 255);
				break;
		}

		if (fQueues[i] == NULL)
			continue;

		if (Polygon* p = fQueues[i]->Head()) {
			view->SetDrawingMode(B_OP_ADD);
			_DrawPolygon(p, view);
		}

		if (Polygon* p = fQueues[i]->Tail()) {
			view->SetDrawingMode(B_OP_SUBTRACT);
			_DrawPolygon(p, view);
		}
	}
}


void
SpiderSaver::_DrawPolygon(Polygon* polygon, BView* view)
{
	int32 pointCount = polygon->CountPoints();
	if (pointCount > 1) {
		BPoint p = polygon->PointAt(0);
		view->MovePenTo(p);
		for (int32 i = 1; i < pointCount; i++)
			view->StrokeLine(polygon->PointAt(i));

		view->StrokeLine(p);
	}
}