/*
 * Copyright (c) 2008-2009 Gerasim Troeglazov (3dEyes**). All Rights Reserved.
 * This file may be used under the terms of the MIT License.
 */


#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include <Bitmap.h>
#include <Catalog.h>
#include <Polygon.h>
#include <Screen.h>
#include <ScreenSaver.h>
#include <StringView.h>
#include <View.h>


class Clock : public BScreenSaver
{
public:
					Clock(BMessage *message, image_id id);
	void			StartConfig(BView *view);
	status_t		StartSaver(BView *view, bool preview);
	void			Draw(BView *view, int32 frame);	
private:
	void 			_drawBlock(BView *view, float x, float y, float alpha,
						float size);
	void 			_drawArrow(BView *view, float x0, float y0, float angle,
						float length, float coeff, float width);
	float 			centerX, centerY;
};


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


Clock::Clock(BMessage *message, image_id image)
	:
	BScreenSaver(message, image)
{
	B_TRANSLATE_MARK_SYSTEM_NAME_VOID("SimpleClock");
}


void
Clock::StartConfig(BView *view)
{
	BStringView	*aboutView = new BStringView(BRect(10, 10, 200, 35),
		B_EMPTY_STRING, "Simple Clock");
	aboutView->SetFont(be_bold_font);
	aboutView->SetFontSize(15);
	view->AddChild(aboutView);
	aboutView = new BStringView(BRect(10, 40, 200, 65),
		B_EMPTY_STRING, " Ver 1.0, ©3dEyes**");
	view->AddChild(aboutView);
}


status_t
Clock::StartSaver(BView *view, bool)
{
	SetTickSize(1000000);
	return B_OK;
}


void
Clock::Draw(BView *view, int32)
{
	BScreen screenView;
	BBitmap bufferBitmap(view->Bounds(), screenView.ColorSpace(), true);
	BView offscreenView(view->Bounds(), NULL, 0, 0);
	bufferBitmap.AddChild(&offscreenView);
	bufferBitmap.Lock();

	float width = view->Bounds().Width();
	float height = view->Bounds().Height();
	float zoom = (height / 1024.0) * 0.65;
	
	time_t timeInfo;
	time(&timeInfo);
	struct tm *nowTime = localtime(&timeInfo);

	float secondVal = nowTime->tm_sec;
	float minuteVal = nowTime->tm_min + (secondVal / 60.0);
	float hourVal = nowTime->tm_hour + (minuteVal / 60.0);

	offscreenView.SetHighColor(0, 0, 0);
	offscreenView.SetLowColor(0, 0, 0);
	offscreenView.FillRect(offscreenView.Bounds());

	offscreenView.SetHighColor(200, 200, 200);
	
	centerX = width / 2.0;
	centerY = height / 2.0;

	float markAngle = 0;
	float markRadius = 510.0 * zoom;

	for(int mark = 0; mark < 60; mark++, markAngle += (2 * M_PI) / 60) {
		float x = centerX + markRadius * cos(markAngle);
		float y = centerY + markRadius * sin(markAngle);
		_drawBlock(&offscreenView, x, y, markAngle, 14.0 * zoom);
	}

	offscreenView.SetHighColor(255, 255, 255);

	markAngle = 0;
	markRadius = 500.0 * zoom;
	
	for (int mark = 0; mark < 12; mark++, markAngle += (2 * M_PI) / 12) {
		float x = centerX + markRadius * cos(markAngle);
		float y = centerY + markRadius * sin(markAngle);
		_drawBlock(&offscreenView, x, y, markAngle, 32 * zoom);
	}

	offscreenView.SetHighColor(255, 255, 255);
	_drawArrow(&offscreenView, centerX, centerY,
		((2 * M_PI / 60) * minuteVal) - (M_PI / 2), 220 * zoom, 1, 8 * zoom);

	_drawArrow(&offscreenView, centerX, centerY,
		((2 * M_PI / 12) * hourVal) - (M_PI / 2), 140 * zoom, 1, 14 * zoom);
	offscreenView.FillEllipse(BPoint(centerX, centerY),
		24 * zoom, 24 * zoom);
	
	offscreenView.SetHighColor(250, 20, 20);
	_drawArrow(&offscreenView, centerX, centerY,
		((2 * M_PI / 60) * secondVal) - (M_PI / 2), 240 * zoom, 1, 4 * zoom);
	offscreenView.FillEllipse(BPoint(centerX, centerY),
		20 * zoom, 20 * zoom);

	offscreenView.Sync();
	bufferBitmap.Unlock();
	view->DrawBitmap(&bufferBitmap);
	bufferBitmap.RemoveChild(&offscreenView);
}


void
Clock::_drawBlock(BView *view, float x, float y, float alpha, float size)
{
	float blockAngles[4] = {alpha - (M_PI / 12), alpha + (M_PI / 12),
		alpha + M_PI - (M_PI / 12), alpha + M_PI + (M_PI / 12)};
	
	BPoint blockPoints[4];
	for (int index = 0; index < 4; index++) {
		blockPoints[index].x = x + size * cos(blockAngles[index]);
		blockPoints[index].y = y + size * sin(blockAngles[index]);
	}
	view->FillPolygon(&blockPoints[0], 4);
}


void
Clock::_drawArrow(BView *view, float x0, float y0, float angle, float length,
	float coeff, float width)
{
	float alpha = width / length;

	float x = x0 + length * cos(angle);
	float y = y0 + length * sin(angle);

	float size = length * coeff;

	float blockAngles[4] = {angle - alpha, angle + alpha,
		angle + M_PI - alpha, angle + M_PI + alpha};

	BPoint blockPoints[4];
	for(int index = 0; index < 4; index++) {
		blockPoints[index].x = x + size * cos(blockAngles[index]);
		blockPoints[index].y = y + size * sin(blockAngles[index]);
	}
	view->FillPolygon(&blockPoints[0], 4);
}