/*
 * Copyright 2006, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 */

#include "Canvas.h"

#include <new>
#include <stdio.h>

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

#include "Layer.h"

using std::nothrow;

// constructor
Canvas::Canvas(BRect frame)
	: BList(10),
	  fBounds(frame)
{
}

// destructor
Canvas::~Canvas()
{
	MakeEmpty();
}

// IsValid
bool
Canvas::IsValid() const
{
	return fBounds.IsValid();
}

// MakeEmpty
void
Canvas::MakeEmpty()
{
	int32 count = CountLayers();
	for (int32 i = 0; i < count; i++)
		delete LayerAtFast(i);
	BList::MakeEmpty();
}

// AddLayer
bool
Canvas::AddLayer(Layer* layer)
{
	return AddLayer(layer, CountLayers());
}

// AddLayer
bool
Canvas::AddLayer(Layer* layer, int32 index)
{
	return layer && AddItem((void*)layer, index);
}

// RemoveLayer
Layer*
Canvas::RemoveLayer(int32 index)
{
	return (Layer*)RemoveItem(index);
}

// RemoveLayer
bool
Canvas::RemoveLayer(Layer* layer)
{
	return RemoveItem((void*)layer);
}

// LayerAt
Layer*
Canvas::LayerAt(int32 index) const
{
	return (Layer*)ItemAt(index);
}

// LayerAtFast
Layer*
Canvas::LayerAtFast(int32 index) const
{
	return (Layer*)ItemAtFast(index);
}

// IndexOf
int32
Canvas::IndexOf(Layer* layer) const
{
	return BList::IndexOf((void*)layer);
}

// CountLayers
int32
Canvas::CountLayers() const
{
	return CountItems();
}

// HasLayer
bool
Canvas::HasLayer(Layer* layer) const
{
	return HasItem((void*)layer);
}

// SetBounds
void
Canvas::SetBounds(BRect bounds)
{
	if (bounds.IsValid())
		fBounds = bounds;
}

// Bounds
BRect
Canvas::Bounds() const
{
	return fBounds;
}

// Compose
void
Canvas::Compose(BBitmap* into, BRect area) const
{
	if (into && into->IsValid()
		&& area.IsValid() && area.Intersects(into->Bounds())) {
		area = area & into->Bounds();
		int32 count = CountLayers();
		for (int32 i = count - 1; Layer* layer = LayerAt(i); i--) {
			layer->Compose(into, area);
		}
	}
}

// Bitmap
BBitmap*
Canvas::Bitmap() const
{
	BBitmap* bitmap = new BBitmap(fBounds, 0, B_RGBA32);
	if (!bitmap->IsValid()) {
		delete bitmap;
		return NULL;
	}

	// this bitmap is uninitialized, clear to black/fully transparent
	memset(bitmap->Bits(), 0, bitmap->BitsLength());
	Compose(bitmap, fBounds);
	// remove image data where alpha = 0 to improve compression later on
	uint8* bits = (uint8*)bitmap->Bits();
	uint32 bpr = bitmap->BytesPerRow();
	uint32 width = bitmap->Bounds().IntegerWidth() + 1;
	uint32 height = bitmap->Bounds().IntegerHeight() + 1;
	while (height > 0) {
		uint8* bitsHandle = bits;
		for (uint32 x = 0; x < width; x++) {
			if (!bitsHandle[3]) {
				bitsHandle[0] = 0;
				bitsHandle[1] = 0;
				bitsHandle[2] = 0;
			}
			bitsHandle += 4;
		}
		bits += bpr;
		height--;
	}

	return bitmap;
}



static const char*	LAYER_KEY			= "layer";
static const char*	BOUNDS_KEY			= "bounds";

// Unarchive
status_t
Canvas::Unarchive(const BMessage* archive)
{
	if (!archive)
		return B_BAD_VALUE;

	// restore bounds
	BRect bounds;
	if (archive->FindRect(BOUNDS_KEY, &bounds) < B_OK)
		return B_ERROR;

	fBounds = bounds;
	// restore each layer
	BMessage layerMessage;
	for (int32 i = 0;
		 archive->FindMessage(LAYER_KEY, i, &layerMessage) == B_OK;
		 i++) {

		Layer* layer = new (nothrow) Layer();
		if (!layer || layer->Unarchive(&layerMessage) < B_OK
			|| !AddLayer(layer)) {
			delete layer;
			return B_NO_MEMORY;
		}
	}

	return B_OK;
}