#include <Application.h>
#include <Bitmap.h>
#include <View.h>
#include <Window.h>
#include <malloc.h>
#include <stdio.h>


#if 0
{
	// usage example for simple rects
	port_id port = find_port("drawing_debugger_port");
	if (port >= 0) {
		write_port_etc(port, 'RECT', &interestingRect, sizeof(BRect),
			B_RELATIVE_TIMEOUT, 0);
	}


	// usage example for regions
	port_id port = find_port("drawing_debugger_port");
	if (port >= 0) {
		int32 rectCount = region->CountRects();
		for (int32 i = 0; i < rectCount; i++) {
			BRect interestingRect = region->RectAt(i);
			write_port_etc(port, 'RECT', &interestingRect, sizeof(BRect),
				B_RELATIVE_TIMEOUT, 0);
		}
	}
}
#endif


class DrawingDebuggerView : public BView {
public:
								DrawingDebuggerView(BRect frame);
virtual							~DrawingDebuggerView();

virtual	void					Draw(BRect updateRect);

private:
static	int32					_PortListener(void *data);

		BBitmap *				fBitmap;
		BView *					fOffscreenView;
		thread_id				fListenerThread;
		bool					fStopListener;
};


class DrawingDebuggerWindow : public BWindow {
public:
								DrawingDebuggerWindow(BRect frame);

private:
		DrawingDebuggerView *	fView;
};


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

private:
		DrawingDebuggerWindow *	fWindow;
};


rgb_color
random_color()
{
	rgb_color result;
	result.red = system_time() % 256;
	result.green = (system_time() >> 8) % 256;
	result.blue = (system_time() >> 16) % 256;
	return result;
}


DrawingDebuggerApp::DrawingDebuggerApp()
	:	BApplication("application/x.vnd-Haiku.DrawingDebugger")
{
	fWindow = new DrawingDebuggerWindow(BRect(200, 200, 999, 799));
	fWindow->Show();
}


DrawingDebuggerWindow::DrawingDebuggerWindow(BRect frame)
	:	BWindow(frame, "DrawingDebugger", B_TITLED_WINDOW,
			B_QUIT_ON_WINDOW_CLOSE)
{
	fView = new DrawingDebuggerView(frame.OffsetToSelf(0, 0));
	AddChild(fView);
}


DrawingDebuggerView::DrawingDebuggerView(BRect frame)
	:	BView(frame, "DrawingDebuggerView", B_FOLLOW_ALL, B_WILL_DRAW)
{
	fBitmap = new BBitmap(frame, B_RGB32, true);
	fOffscreenView= new BView(frame, "OffscreenView", B_FOLLOW_NONE, 0);
	fOffscreenView->SetViewColor(B_TRANSPARENT_32_BIT);
	fBitmap->AddChild(fOffscreenView);

	fStopListener = false;
	fListenerThread = spawn_thread(_PortListener, "port_listener",
		B_NORMAL_PRIORITY, this);
	resume_thread(fListenerThread);
}


DrawingDebuggerView::~DrawingDebuggerView()
{
	fStopListener = true;
	int32 returnCode = B_OK;
	wait_for_thread(fListenerThread, &returnCode);
	delete fBitmap;
}


void
DrawingDebuggerView::Draw(BRect updateRect)
{
	DrawBitmap(fBitmap, updateRect, updateRect);
}


int32
DrawingDebuggerView::_PortListener(void *data)
{
	DrawingDebuggerView *view = (DrawingDebuggerView *)data;
	port_id port = create_port(1000, "drawing_debugger_port");
	if (port < 0) {
		printf("failed to create port\n");
		return port;
	}

	size_t bufferSize = 1024;
	uint8 *buffer = (uint8 *)malloc(bufferSize);
	if (buffer == NULL)
		return B_NO_MEMORY;

	while (!view->fStopListener) {
		int32 code = 0;
		status_t result = read_port_etc(port, &code, buffer, bufferSize,
			B_RELATIVE_TIMEOUT, 100000);
		if (result == B_INTERRUPTED || result == B_TIMED_OUT)
			continue;
		if (result < B_OK) {
			printf("failed to read from port\n");
			return result;
		}

		switch (code) {
			case 'RECT':
			{
				BRect *rect = (BRect *)buffer;
				view->fBitmap->Lock();
				view->fOffscreenView->SetHighColor(random_color());
				view->fOffscreenView->FillRect(*rect, B_SOLID_HIGH);
				view->fOffscreenView->Sync();
				view->fBitmap->Unlock();

				view->LockLooper();
				view->Invalidate(*rect);
				view->UnlockLooper();
				break;
			}

			default:
				printf("unsupported code '%.4s'\n", (char *)&code);
				break;
		}
	}

	free(buffer);
	delete_port(port);
	return 0;
}


int
main(int argc, const char *argv[])
{
	DrawingDebuggerApp *app = new DrawingDebuggerApp();
	app->Run();
	delete app;
	return 0;
}