#include <Application.h>
#include <DirectWindow.h>
#include <View.h>

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

#include "AccelerantHWInterface.h"
#include "Desktop.h"
#include "DirectWindowBuffer.h"
#include "DrawingEngine.h"
#include "DrawView.h"
#include "ViewLayer.h"
#include "WindowLayer.h"

class App : public BApplication {
 public:
						App();

	virtual void		ReadyToRun();
};

class Window : public BDirectWindow {
 public:
								Window(const char* title);
	virtual						~Window();

	virtual	bool				QuitRequested();

	virtual void				DirectConnected(direct_buffer_info* info);

			void				AddWindow(BRect frame, const char* name);
			void				Test();
 private:
		DrawView*				fView;
		Desktop*				fDesktop;
		bool					fQuit;
		DirectWindowBuffer		fBuffer;
		AccelerantHWInterface	fInterface;
		DrawingEngine			fEngine;

};

// constructor
App::App()
	: BApplication("application/x-vnd.stippi.ClippingTest")
{
	srand(real_time_clock_usecs());
}

// ReadyToRun
void
App::ReadyToRun()
{
	Window* win = new Window("clipping");
	win->Show();

//	win->Test();
}

// constructor
Window::Window(const char* title)
	: BDirectWindow(BRect(50, 50, 800, 650), title,
					B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL, B_ASYNCHRONOUS_CONTROLS),
	  fQuit(false),
	  fBuffer(),
	  fInterface(),
	  fEngine(&fInterface, &fBuffer)
{
	fInterface.Initialize();
	fView = new DrawView(Bounds());
	AddChild(fView);
	fView->MakeFocus(true);

	fDesktop = new Desktop(fView, &fEngine);
	fDesktop->Run();
}

// destructor
Window::~Window()
{
	fInterface.Shutdown();
	fDesktop->Lock();
	fDesktop->Quit();
}

// QuitRequested
bool
Window::QuitRequested()
{
/*	if (!fQuit) {
		fDesktop->PostMessage(MSG_QUIT);
		fQuit = true;
		return false;
	}*/
be_app->PostMessage(B_QUIT_REQUESTED);
	return true;
}

// #pragma mark -

void
fill_line_8(uint8* buffer, int32 pixels, uint8 r, uint8 g, uint8 b)
{
	for (int32 i = 0; i < pixels; i++) {
		*buffer++ = b;
		*buffer++ = g;
		*buffer++ = r;
		*buffer++ = 255;
	}
}

void
fill_line_32(uint8* buffer, int32 pixels, uint8 r, uint8 g, uint8 b)
{
	uint32 pixel;
	uint32* handle = (uint32*)buffer;
	for (int32 i = 0; i < pixels; i++) {
		pixel = 0xff000000 | (r << 16) | (g << 8) | (b);
		*handle++ = pixel;
	}
}

void
fill_line_64(uint8* buffer, int32 pixels, uint8 r, uint8 g, uint8 b)
{
	uint64 pixel;
	uint64* handle = (uint64*)buffer;
	pixels /= 2;
	for (int32 i = 0; i < pixels; i++) {
		pixel = 0xff000000 | (r << 16) | (g << 8) | (b);
		pixel = pixel << 32;
		pixel |= 0xff000000 | (r << 16) | (g << 8) | (b);
		*handle++ = pixel;
	}
}

void
test1(uint8* buffer, uint32 bpr)
{
	uint8* handle = buffer;

/*	bigtime_t start8 = system_time();
	for (int32 x = 0; x < 1000; x++) {
		handle = buffer;
		for (int32 i = 0; i < 64; i++) {
			fill_line_8(handle, 512, 255, 0, 255);
			handle += bpr;
		}
	}

	bigtime_t start32 = system_time();
	for (int32 x = 0; x < 1000; x++) {
		handle = buffer;
		for (int32 i = 0; i < 64; i++) {
			fill_line_32(handle, 512, 255, 0, 255);
			handle += bpr;
		}
	}

	bigtime_t start64 = system_time();
	for (int32 x = 0; x < 1000; x++) {*/
		handle = buffer;
		for (int32 i = 0; i < 640; i++) {
			fill_line_64(handle, 512, 0, 255, 255);
			handle += bpr;
		}
/*	}


	bigtime_t finish = system_time();
	printf("8:  %lld\n", start32 - start8);
	printf("32: %lld\n", start64 - start32);
	printf("64: %lld\n", finish - start64);*/
}
	
// #pragma mark -

void
blend_line_8(uint8* buffer, int32 pixels, uint8 r, uint8 g, uint8 b, uint8 a)
{
	for (int32 i = 0; i < pixels; i++) {
		buffer[0] = ((b - buffer[0]) * a + (buffer[0] << 8)) >> 8;
		buffer[1] = ((g - buffer[1]) * a + (buffer[1] << 8)) >> 8;
		buffer[2] = ((r - buffer[2]) * a + (buffer[2] << 8)) >> 8;;
		buffer[3] = a;
		buffer += 4;
	}
}

union pixel {
	uint32	data32;
	uint8	data8[4];
};

void
blend_line_32(uint8* buffer, int32 pixels, uint8 r, uint8 g, uint8 b, uint8 a)
{
	pixel p;
	pixels /= 2;
	for (int32 i = 0; i < pixels; i++) {
		p.data32 = *(uint32*)buffer;

		p.data8[0] = ((b - p.data8[0]) * a + (p.data8[0] << 8)) >> 8;
		p.data8[1] = ((g - p.data8[1]) * a + (p.data8[1] << 8)) >> 8;
		p.data8[2] = ((r - p.data8[2]) * a + (p.data8[2] << 8)) >> 8;
		p.data8[3] = 255;
		*((uint32*)buffer) = p.data32;
		buffer += 4;

		p.data32 = *(uint32*)buffer;

		p.data8[0] = ((b - p.data8[0]) * a + (p.data8[0] << 8)) >> 8;
		p.data8[1] = ((g - p.data8[1]) * a + (p.data8[1] << 8)) >> 8;
		p.data8[2] = ((r - p.data8[2]) * a + (p.data8[2] << 8)) >> 8;
		p.data8[3] = 255;
		*((uint32*)buffer) = p.data32;
		buffer += 4;
	}
}

union pixel2 {
	uint64	data64;
	uint8	data8[8];
};

// gfxcpy32
// * numBytes is expected to be a multiple of 4
inline
void
gfxcpy32(uint8* dst, uint8* src, int32 numBytes)
{
	uint64* d64 = (uint64*)dst;
	uint64* s64 = (uint64*)src;
	int32 numBytesStart = numBytes;
	while (numBytes >= 32) {
		*d64++ = *s64++;
		*d64++ = *s64++;
		*d64++ = *s64++;
		*d64++ = *s64++;
		numBytes -= 32;
	}
	if (numBytes >= 16) {
		*d64++ = *s64++;
		*d64++ = *s64++;
		numBytes -= 16;
	}
	if (numBytes >= 8) {
		*d64++ = *s64++;
		numBytes -= 8;
	}
	if (numBytes == 4) {
		uint32* d32 = (uint32*)(dst + numBytesStart - numBytes);
		uint32* s32 = (uint32*)(src + numBytesStart - numBytes);
		*d32 = *s32;
	}
}

void
blend_line_64(uint8* buffer, int32 pixels, uint8 r, uint8 g, uint8 b, uint8 a)
{
	pixel2 p;
	pixels /= 2;

	r = (r * a) >> 8;
	g = (g * a) >> 8;
	b = (b * a) >> 8;
	a = 255 - a;

	uint8 tempBuffer[pixels * 8];

	uint8* t = tempBuffer;
	uint8* s = buffer;

	for (int32 i = 0; i < pixels; i++) {
		p.data64 = *(uint64*)s;

		t[0] = ((p.data8[0] * a) >> 8) + b;
		t[1] = ((p.data8[1] * a) >> 8) + g;
		t[2] = ((p.data8[2] * a) >> 8) + r;

		t[4] = ((p.data8[4] * a) >> 8) + b;
		t[5] = ((p.data8[5] * a) >> 8) + g;
		t[6] = ((p.data8[6] * a) >> 8) + r;

		t += 8;
		s += 8;
	}

	gfxcpy32(buffer, tempBuffer, pixels * 8);
}
void
test2(uint8* buffer, uint32 bpr)
{
	uint8* handle = buffer;

/*	bigtime_t start8 = system_time();
//	for (int32 x = 0; x < 10; x++) {
		handle = buffer;
		for (int32 i = 0; i < 64; i++) {
			blend_line_8(handle, 512, 255, 0, 0, 20);
			handle += bpr;
		}
//	}

	bigtime_t start32 = system_time();
//	for (int32 x = 0; x < 10; x++) {
		handle = buffer;
		for (int32 i = 0; i < 64; i++) {
			blend_line_32(handle, 512, 255, 0, 0, 20);
			handle += bpr;
		}
//	}*/

	bigtime_t start64 = system_time();
//	for (int32 x = 0; x < 10; x++) {
		handle = buffer;
		for (int32 i = 0; i < 640; i++) {
			blend_line_64(handle, 512, 255, 0, 0, 200);
			handle += bpr;
		}
//	}

	bigtime_t finish = system_time();
//	printf("8:  %lld\n", start32 - start8);
//	printf("32: %lld\n", start64 - start32);
	printf("blend 64: %lld\n", finish - start64);
}
	
// #pragma mark -

// DirectConnected
void
Window::DirectConnected(direct_buffer_info* info)
{
	// TODO: for some reason, this deadlocks
	// on B_DIRECT_STOP... be aware
//	fDesktop->LockClipping();

//	fEngine.Lock();
	
	switch(info->buffer_state & B_DIRECT_MODE_MASK) {
		case B_DIRECT_START:
		case B_DIRECT_MODIFY:
			fBuffer.SetTo(info);
			fDesktop->SetOffset(info->window_bounds.left, info->window_bounds.top);
			test2((uint8*)info->bits, info->bytes_per_row);
			break;
		case B_DIRECT_STOP:
			fBuffer.SetTo(NULL);
			break;
	}

//	fDesktop->SetMasterClipping(&fBuffer.WindowClipping());

//	fEngine.Unlock();

//	fDesktop->UnlockClipping();
}

// AddWindow
void
Window::AddWindow(BRect frame, const char* name)
{
	WindowLayer* window = new WindowLayer(frame, name,
										  fDesktop->GetDrawingEngine(),
										  fDesktop);

	// add a coupld children
	frame.OffsetTo(B_ORIGIN);
	frame.InsetBy(5.0, 5.0);
	if (frame.IsValid()) {
		ViewLayer* layer1 = new ViewLayer(frame, "View 1",
										  B_FOLLOW_ALL,
										  B_FULL_UPDATE_ON_RESIZE, 
										  (rgb_color){ 180, 180, 180, 255 });

		frame.OffsetTo(B_ORIGIN);
		frame.InsetBy(15.0, 15.0);
		if (frame.IsValid()) {

			BRect f = frame;
			f.bottom = f.top + f.Height() / 3 - 3;
			f.right = f.left + f.Width() / 3 - 3;

			// top row of views
			ViewLayer* layer;
			layer = new ViewLayer(f, "View", B_FOLLOW_LEFT | B_FOLLOW_TOP,
								  B_FULL_UPDATE_ON_RESIZE, (rgb_color){ 120, 120, 120, 255 });
			layer1->AddChild(layer);

			f.OffsetBy(f.Width() + 6, 0);

			layer = new ViewLayer(f, "View", B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP,
								  B_FULL_UPDATE_ON_RESIZE, (rgb_color){ 120, 120, 120, 255 });
			layer1->AddChild(layer);

			f.OffsetBy(f.Width() + 6, 0);

			layer = new ViewLayer(f, "View", B_FOLLOW_RIGHT | B_FOLLOW_TOP,
								  B_FULL_UPDATE_ON_RESIZE, (rgb_color){ 120, 120, 120, 255 });
			layer1->AddChild(layer);

			// middle row of views
			f = frame;
			f.bottom = f.top + f.Height() / 3 - 3;
			f.right = f.left + f.Width() / 3 - 3;
			f.OffsetBy(0, f.Height() + 6);

			layer = new ViewLayer(f, "View", B_FOLLOW_LEFT | B_FOLLOW_TOP_BOTTOM,
								  B_FULL_UPDATE_ON_RESIZE, (rgb_color){ 120, 120, 120, 255 });
			layer1->AddChild(layer);

			f.OffsetBy(f.Width() + 6, 0);

			layer = new ViewLayer(f, "View", B_FOLLOW_ALL,
								  B_FULL_UPDATE_ON_RESIZE, (rgb_color){ 120, 120, 120, 255 });
			layer1->AddChild(layer);

			f.OffsetBy(f.Width() + 6, 0);

			layer = new ViewLayer(f, "View", B_FOLLOW_RIGHT | B_FOLLOW_TOP_BOTTOM,
								  B_FULL_UPDATE_ON_RESIZE, (rgb_color){ 120, 120, 120, 255 });
			layer1->AddChild(layer);

			// bottom row of views
			f = frame;
			f.bottom = f.top + f.Height() / 3 - 3;
			f.right = f.left + f.Width() / 3 - 3;
			f.OffsetBy(0, 2 * f.Height() + 12);

			layer = new ViewLayer(f, "View", B_FOLLOW_LEFT | B_FOLLOW_BOTTOM,
								  B_FULL_UPDATE_ON_RESIZE, (rgb_color){ 120, 120, 120, 255 });
			layer1->AddChild(layer);

			f.OffsetBy(f.Width() + 6, 0);

//			layer = new ViewLayer(f, "View", B_FOLLOW_LEFT_RIGHT | B_FOLLOW_BOTTOM,
			layer = new ViewLayer(f, "View", B_FOLLOW_LEFT | B_FOLLOW_BOTTOM,
								  B_FULL_UPDATE_ON_RESIZE, (rgb_color){ 120, 120, 120, 255 });
			layer1->AddChild(layer);

			f.OffsetBy(f.Width() + 6, 0);

//			layer = new ViewLayer(f, "View", B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM,
			layer = new ViewLayer(f, "View", B_FOLLOW_LEFT | B_FOLLOW_BOTTOM,
								  B_FULL_UPDATE_ON_RESIZE, (rgb_color){ 120, 120, 120, 255 });
			layer1->AddChild(layer);
		}

		window->AddChild(layer1);
	}

	window->Run();

	BMessage message(MSG_ADD_WINDOW);
	message.AddPointer("window", (void*)window);
	fDesktop->PostMessage(&message);
}

// Test
void
Window::Test()
{
	BRect frame(20, 20, 330, 230);
//	AddWindow(frame, "Window 1");
//	AddWindow(frame, "Window 2");
	for (int32 i = 0; i < 20; i++) {
		BString name("Window ");
		frame.OffsetBy(20, 15);
		name << i + 1;
		AddWindow(frame, name.String());
	}

/*	frame.Set(10, 80, 320, 290);
	for (int32 i = 20; i < 40; i++) {
		BString name("Window ");
		frame.OffsetBy(20, 15);
		name << i + 1;
		AddWindow(frame, name.String());
	}

	frame.Set(20, 140, 330, 230);
	for (int32 i = 40; i < 60; i++) {
		BString name("Window ");
		frame.OffsetBy(20, 15);
		name << i + 1;
		AddWindow(frame, name.String());
	}

	frame.Set(20, 200, 330, 230);
	for (int32 i = 60; i < 80; i++) {
		BString name("Window ");
		frame.OffsetBy(20, 15);
		name << i + 1;
		AddWindow(frame, name.String());
	}

	frame.Set(20, 260, 330, 230);
// 99 windows are ok, the 100th looper does not run anymore,
// I guess I'm hitting a BeOS limit (max loopers per app?)
	for (int32 i = 80; i < 99; i++) {
		BString name("Window ");
		frame.OffsetBy(20, 15);
		name << i + 1;
		AddWindow(frame, name.String());
	}*/
}

// main
int
main(int argc, const char* argv[])
{
	srand((long int)system_time());

	App app;
	app.Run();
	return 0;
}