/*
 * Copyright (C) 2001-2010 Stephan Aßmus. All rights reserved.
 * Distributed under the terms of the MIT license.
 *
 * Copyright (C) 1998-1999 Be Incorporated. All rights reseved.
 * Distributed under the terms of the Be Sample Code license.
 */


#include "PeakView.h"

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

#include <Bitmap.h>
#include <Catalog.h>
#include <ControlLook.h>
#include <Locale.h>
#include <MenuItem.h>
#include <Message.h>
#include <MessageRunner.h>
#include <Messenger.h>
#include <PopUpMenu.h>
#include <Window.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "MediaPlayer-PeakView"


using std::nothrow;


enum {
	MSG_PULSE		= 'puls',
	MSG_LOCK_PEAKS	= 'lpks'
};


PeakView::PeakView(const char* name, bool useGlobalPulse, bool displayLabels)
	:
	BView(name, (useGlobalPulse ? B_PULSE_NEEDED : 0)
		| B_WILL_DRAW | B_FRAME_EVENTS | B_FULL_UPDATE_ON_RESIZE),
	fUseGlobalPulse(useGlobalPulse),
	fDisplayLabels(displayLabels),
	fPeakLocked(false),

	fRefreshDelay(20000),
	fPulse(NULL),

	fChannelInfos(NULL),
	fChannelCount(0),
	fGotData(true),

	fBackBitmap(NULL),
	fPeakNotificationWhat(0)
{
	GetFontHeight(&fFontHeight);

	SetLowColor(ui_color(B_PANEL_BACKGROUND_COLOR));
	SetViewColor(B_TRANSPARENT_COLOR);

	SetChannelCount(2);
}


PeakView::~PeakView()
{
	delete fPulse;
	delete fBackBitmap;
	delete[] fChannelInfos;
}


void
PeakView::MessageReceived(BMessage* message)
{
	if (message->what == fPeakNotificationWhat) {
		float max;
		for (int32 i = 0; message->FindFloat("max", i, &max) == B_OK; i++)
			SetMax(max, i);
		fGotData = true;
		return;
	}

	switch (message->what) {
		case MSG_PULSE:
			Pulse();
			break;

		case MSG_LOCK_PEAKS:
			fPeakLocked = !fPeakLocked;
			break;

		default:
			BView::MessageReceived(message);
			break;
	}
}


void
PeakView::AttachedToWindow()
{
	if (!fUseGlobalPulse) {
		delete fPulse;
		BMessage message(MSG_PULSE);
		fPulse = new BMessageRunner(BMessenger(this), &message,
			fRefreshDelay);
	}
}


void
PeakView::DetachedFromWindow()
{
	delete fPulse;
	fPulse = NULL;
}


void
PeakView::MouseDown(BPoint where)
{
	int32 buttons;
	if (Window()->CurrentMessage()->FindInt32("buttons", &buttons) < B_OK)
		buttons = B_PRIMARY_MOUSE_BUTTON;

	if (buttons & B_PRIMARY_MOUSE_BUTTON) {
		// Reset the overshot flag and set the observed max to the current
		// value.
		for (uint32 i = 0; i < fChannelCount; i++) {
			fChannelInfos[i].last_overshot_time = -5000000;
			fChannelInfos[i].last_max = fChannelInfos[i].current_max;
		}
	} else if (buttons & B_TERTIARY_MOUSE_BUTTON) {
		// Toggle locking of the observed max value.
		fPeakLocked = !fPeakLocked;
	} else {
		// Display context menu
		BPopUpMenu* menu = new BPopUpMenu("peak context menu");
		BMenuItem* item = new BMenuItem(B_TRANSLATE("Lock Peaks"),
			new BMessage(MSG_LOCK_PEAKS));
		item->SetMarked(fPeakLocked);
		menu->AddItem(item);
		menu->SetTargetForItems(this);

		menu->SetAsyncAutoDestruct(true);
		menu->SetFont(be_plain_font);
	
		where = ConvertToScreen(where);
		bool keepOpen = false; // ?
		if (keepOpen) {
			BRect mouseRect(where, where);
			mouseRect.InsetBy(-3.0, -3.0);
			where += BPoint(3.0, 3.0);
			menu->Go(where, true, false, mouseRect, true);
		} else {
			where += BPoint(3.0, 3.0);
			menu->Go(where, true, false, true);
		}
	}
}


void
PeakView::Draw(BRect updateRect)
{
	BRect r(_BackBitmapFrame());
	float width = r.Width();
	r.InsetBy(-2.0, -2.0);

	be_control_look->DrawTextControlBorder(this, r, updateRect, LowColor());

	// peak bitmap
	if (fBackBitmap)
		_DrawBitmap();

	// dB labels
	if (fDisplayLabels) {
		font_height fh;
		GetFontHeight(&fh);
		float y = Bounds().bottom;
		y -= fh.descent;
		DrawString("0", BPoint(4.0 + width - StringWidth("0"), y));
		DrawString("-6", BPoint(0.477 * width, y));
		DrawString("-12", BPoint(0.227 * width, y));
	}
}


void
PeakView::FrameResized(float width, float height)
{
	BRect bitmapFrame = _BackBitmapFrame();
	_ResizeBackBitmap(bitmapFrame.IntegerWidth() + 1, fChannelCount);
	_UpdateBackBitmap();
}


void
PeakView::Pulse()
{
	if (!fGotData)
		return;

	if (fBackBitmap == NULL)
		return;

	if (!fPeakLocked) {
		for (uint32 i = 0; i < fChannelCount; i++) {
			fChannelInfos[i].last_max *= 0.96f;
			if (fChannelInfos[i].current_max > fChannelInfos[i].last_max)
				fChannelInfos[i].last_max = fChannelInfos[i].current_max;
		}
	}
	_UpdateBackBitmap();

	for (uint32 i = 0; i < fChannelCount; i++)
		fChannelInfos[i].current_max = 0.0f;
	fGotData = false;

	_DrawBitmap();
	Flush();
}


BSize
PeakView::MinSize()
{
	float minWidth = 20 + 4;
	float minHeight = 2 * 8 - 1 + 4;
	if (fDisplayLabels) {
		font_height fh;
		GetFontHeight(&fh);
		minWidth = max_c(60.0, minWidth);
		minHeight += ceilf(fh.ascent + fh.descent);
	}
	return BSize(minWidth, minHeight);
}


bool
PeakView::IsValid() const
{
	return fBackBitmap != NULL && fBackBitmap->IsValid()
		&& fChannelInfos != NULL;
}


void
PeakView::SetPeakRefreshDelay(bigtime_t delay)
{
	if (fRefreshDelay == delay)
		return;

	fRefreshDelay = delay;

	if (fPulse != NULL)
		fPulse->SetInterval(fRefreshDelay);
}


void
PeakView::SetPeakNotificationWhat(uint32 what)
{
	fPeakNotificationWhat = what;
}


void
PeakView::SetChannelCount(uint32 channelCount)
{
	if (channelCount == fChannelCount)
		return;

	delete[] fChannelInfos;
	fChannelInfos = new(std::nothrow) ChannelInfo[channelCount];
	if (fChannelInfos != NULL) {
		fChannelCount = channelCount;
		for (uint32 i = 0; i < fChannelCount; i++) {
			fChannelInfos[i].current_max = 0.0f;
			fChannelInfos[i].last_max = 0.0f;
			fChannelInfos[i].last_overshot_time = -5000000;
		}
		_ResizeBackBitmap(_BackBitmapFrame().IntegerWidth() + 1,
			fChannelCount);
	} else
		fChannelCount = 0;
}


void
PeakView::SetMax(float max, uint32 channel)
{
	if (channel >= fChannelCount)
		return;

	if (fChannelInfos[channel].current_max < max)
		fChannelInfos[channel].current_max = max;

	if (fChannelInfos[channel].current_max > 1.0)
		fChannelInfos[channel].last_overshot_time = system_time();
}


// #pragma mark -


BRect
PeakView::_BackBitmapFrame() const
{
	BRect frame = Bounds();
	frame.InsetBy(2, 2);
	if (fDisplayLabels)
		frame.bottom -= ceilf(fFontHeight.ascent + fFontHeight.descent);
	return frame;
}


void
PeakView::_ResizeBackBitmap(int32 width, int32 channels)
{
	if (fBackBitmap != NULL) {
		if (fBackBitmap->Bounds().IntegerWidth() + 1 == width
			&& fBackBitmap->Bounds().IntegerHeight() + 1 == channels) {
			return;
		}
	}
	if (channels <= 0)
		channels = 2;

	delete fBackBitmap;
	BRect bounds(0, 0, width - 1, channels - 1);
	fBackBitmap = new(std::nothrow) BBitmap(bounds, 0, B_RGB32);
	if (fBackBitmap == NULL || !fBackBitmap->IsValid()) {
		delete fBackBitmap;
		fBackBitmap = NULL;
		return;
	}
	memset(fBackBitmap->Bits(), 0, fBackBitmap->BitsLength());
	fGotData = true;
}


void
PeakView::_UpdateBackBitmap()
{
	if (!fBackBitmap)
		return;

	uint8* span = (uint8*)fBackBitmap->Bits();
	uint32 width = fBackBitmap->Bounds().IntegerWidth() + 1;
	for (uint32 i = 0; i < fChannelCount; i++) {
		_RenderSpan(span, width, fChannelInfos[i].current_max,
			fChannelInfos[i].last_max,
			system_time() - fChannelInfos[i].last_overshot_time < 2000000);
		span += fBackBitmap->BytesPerRow();
	}
}


void
PeakView:: _RenderSpan(uint8* span, uint32 width, float current, float peak,
	bool overshot)
{
	uint8 emptyR = 15;
	uint8 emptyG = 36;
	uint8 emptyB = 16;

	uint8 fillR = 41;
	uint8 fillG = 120;
	uint8 fillB = 45;

	uint8 currentR = 45;
	uint8 currentG = 255;
	uint8 currentB = 45;

	uint8 lastR = 255;
	uint8 lastG = 229;
	uint8 lastB = 87;

	uint8 overR = 255;
	uint8 overG = 89;
	uint8 overB = 7;

	uint8 kFadeFactor = 100;

	uint32 evenWidth = width - width % 2;
	uint32 split = (uint32)(current * (evenWidth - 1) + 0.5);
	split += split & 1;
	uint32 last = (uint32)(peak * (evenWidth - 1) + 0.5);
	last += last & 1;
	uint32 over = overshot ? evenWidth : evenWidth + 1;
	over += over & 1;

	for (uint32 x = 0; x < width; x += 2) {
		uint8 fadedB = (uint8)(((int)span[0] * kFadeFactor) >> 8);
		uint8 fadedG = (uint8)(((int)span[1] * kFadeFactor) >> 8);
		uint8 fadedR = (uint8)(((int)span[2] * kFadeFactor) >> 8);
		if (x < split) {
			span[0] = max_c(fillB, fadedB);
			span[1] = max_c(fillG, fadedG);
			span[2] = max_c(fillR, fadedR);
		} else if (x == split) {
			span[0] = currentB;
			span[1] = currentG;
			span[2] = currentR;
		} else if (x > split) {
			span[0] = max_c(emptyB, fadedB);
			span[1] = max_c(emptyG, fadedG);
			span[2] = max_c(emptyR, fadedR);
		}
		if (x == last) {
			span[0] = lastB;
			span[1] = lastG;
			span[2] = lastR;
		}
		if (x == over) {
			span[0] = overB;
			span[1] = overG;
			span[2] = overR;
		}
		span += 8;
	}
}


void
PeakView::_DrawBitmap()
{
	SetHighColor(0, 0, 0);
	BRect bitmapFrame = _BackBitmapFrame();
	BRect bitmapRect = fBackBitmap->Bounds();
	bitmapRect.bottom = bitmapRect.top;
	float channelHeight = (bitmapFrame.Height() + 1) / fChannelCount;
	for (uint32 i = 0; i < fChannelCount; i++) {
		BRect viewRect(bitmapFrame);
		viewRect.bottom = viewRect.top;
		viewRect.top += floorf(i * channelHeight + 0.5);
		if (i < fChannelCount - 1) {
			viewRect.bottom += floorf((i + 1) * channelHeight + 0.5) - 2;
			StrokeLine(BPoint(viewRect.left, viewRect.bottom + 1),
				BPoint(viewRect.right, viewRect.bottom + 1));
		} else
			viewRect.bottom += floorf((i + 1) * channelHeight + 0.5) - 1;
		DrawBitmapAsync(fBackBitmap, bitmapRect, viewRect);
		bitmapRect.OffsetBy(0, 1);
	}
}