#include <algorithm>
#include <cassert>
#include <cmath>
#include <thread>
#include <functional>
#include <QPainter>
#include <QBrush>
#include <QLinearGradient>
#include <QRect>
#include <QString>
#include <QStyle>
#include "vuMeterWidget.hpp"
#include "control_port.hpp"
#include "utils/string_view_utils.hpp"
#include "astat.h"

namespace{

	static constexpr int meterVerticalPad = 5;
	static constexpr int meterBarPad = 2;
	static constexpr double zeroLevel = -40.0;

}//anon namespace

VuMeterWidget::VuMeterWidget(QWidget *parent) :
	QWidget(parent),
	peak {0.0},
	rms {0.0},
	barLevel {0.0},
	rmsLevel {0.0},
	updatesPerSecond(24)
{
	connect(&timer, SIGNAL(timeout()), this, SLOT(updateVal()));
	timer.start(1000/updatesPerSecond);
}

void VuMeterWidget::parseLine(std::string_view line){
	if(!sv_is_prefix(line, parsePrefix))
		return;

	line.remove_prefix(parsePrefix.size());

	for(channels = 0; !line.empty() && channels < max_channels; channels++){
		auto rmsTag = tokenize(line, ' ');
		if(!sv_is_prefix(rmsTag, "volrms"))
			return;
		auto rms_sv = tokenize(line, ' ');

		auto peakTag = tokenize(line, ' ');
		if(!sv_is_prefix(peakTag, "volpeak"))
			return;
		auto peak_sv = tokenize(line, ' ');

		double ch_rms = 0;
		double ch_peak = 0;
		if(!parse_num(rms_sv, ch_rms)
				|| !parse_num(peak_sv, ch_peak))
		{
			return;
		}

		peak[channels] = ch_peak;
		rms[channels] = ch_rms;
	}

	lastUpdate = clock::now();
}

void VuMeterWidget::setControlPort(ControlPort *controlPort){
	this->controlPort = controlPort;

	using namespace std::placeholders;
	controlPort->addLineCallback(std::bind(&VuMeterWidget::parseLine, this, _1));
	connect(controlPort, &ControlPort::connected, this, &VuMeterWidget::onControlPortConnect);
}

void VuMeterWidget::setParsePrefix(std::string_view prefix){
	parsePrefix = prefix;
}

void VuMeterWidget::updateVal(){
	const double fallSpeed = 200.0;
	const double maximumPeakFallSpeed = 10.0;
	auto maximumPeakHoldTime = std::chrono::seconds(2);

	connected = controlPort->getState() == QAbstractSocket::ConnectedState;

	for(int i = 0; i < channels; i++){
		auto& maxPeak = maximumLevel[i];
		auto now = clock::now();

		barLevel[i] = std::max(barLevel[i] - fallSpeed / updatesPerSecond, 0.0);
		rmsLevel[i] = std::max(rmsLevel[i] - fallSpeed / updatesPerSecond, 0.0);
		if(now - maxPeak.ts > maximumPeakHoldTime){
			maxPeak.val = std::max(maxPeak.val - maximumPeakFallSpeed / updatesPerSecond, 0.0);
		}

		double newPeakHeight = 100 - std::max(peak[i], zeroLevel) * (100 / zeroLevel);
		double newRmsHeight = 100 - std::max(rms[i], zeroLevel) * (100 / zeroLevel);

		barLevel[i] = std::max(barLevel[i], newPeakHeight);
		rmsLevel[i] = std::max(rmsLevel[i], newRmsHeight);

		if(barLevel[i] >= maxPeak.val){
			maxPeak.val = barLevel[i];
			maxPeak.ts = now;
		}
	}

	update();
}

void VuMeterWidget::onControlPortConnect(){
	assert(controlPort);
	controlPort->writeLine("stats on\r\n");
	lastUpdate = clock::time_point();
}

void VuMeterWidget::paintMeter(QPainter& painter,
		int x,
		int y,
		int width,
		int height,
		double peak,
		double rms,
		double maxPeak)
{
	const int meterBarPadHorizontal = 1;
	const int in_width = width - meterBarPadHorizontal * 2;
	const int in_full_height = height - meterBarPad * 2;

	int barHeight = in_full_height * (peak / 100);
	int rmsHeight = in_full_height * (rms / 100);
	int maxPeakHeight = in_full_height * (maxPeak / 100);

	QLinearGradient gradient(0, 0, in_width, in_full_height);
	gradient.setColorAt(0, Qt::red);
	gradient.setColorAt(0.25, Qt::yellow);
	gradient.setColorAt(0.5, Qt::green);
	gradient.setColorAt(1, Qt::green);
	QBrush brush(gradient);

	using namespace std::chrono_literals;
	bool enabled = connected && (clock::now() - lastUpdate <= 2s);

	painter.fillRect(x, y + 1, width, height - 2, enabled ? Qt::black : Qt::gray);
	if(!enabled)
		return;

	painter.fillRect(x + meterBarPadHorizontal,
			y + meterBarPad + (in_full_height - barHeight),
			in_width, barHeight,
			brush);

	int maxPos = y + meterBarPad + (in_full_height - maxPeakHeight);
	QPen maxLevelPen(brush, 1);
	painter.setPen(maxLevelPen);
	painter.drawLine(x + meterBarPadHorizontal, maxPos, x + in_width, maxPos);

	QPen rmsPen(Qt::blue);
	rmsPen.setWidth(4);
	painter.setPen(rmsPen);
	int pos = y + meterBarPad + (in_full_height - rmsHeight);
	painter.drawLine(x + meterBarPadHorizontal, pos, x + in_width, pos);
}

void VuMeterWidget::paintScale(QPainter& painter,
		int x,
		int y,
		int width,
		int height,
		bool leftTicks,
		bool rightTicks)
{
	const int barHeight = height - meterVerticalPad * 2 - meterBarPad * 2;	
	const int barStart = y + meterVerticalPad + meterBarPad;
	const float stepPx = (float) barHeight / std::fabs(zeroLevel);

	painter.setPen(connected ? Qt::black : Qt::gray);
	int i = 0;

	int textPosX;
	if(leftTicks && rightTicks){
		textPosX = x + width / 2 - 8;
	} else if(leftTicks){
		textPosX = x + width - 16;
	} else {
		textPosX = x;
	}

	for(float y = barStart; y <= barStart + barHeight + 0.1; y += stepPx){
		static const int lineLenghtSmall = 2;
		static const int lineLenghtMid = 4;
		static const int lineLenghtLarge = 6;
		static const int drawThreshold = 4;
		if(i % 10 == 0){
			if(leftTicks) painter.drawLine(x, y, x + lineLenghtLarge, y);
			if(rightTicks) painter.drawLine(x + width - lineLenghtLarge, y, x + width, y);
			painter.drawText(QRect(textPosX, y - 6, 16, 12), Qt::AlignCenter,QString::number(i));
		} else if(i % 5 == 0){
			if(leftTicks) painter.drawLine(x, y, x + lineLenghtMid, y);
			if(rightTicks) painter.drawLine(x + width - lineLenghtMid, y, x + width, y);
		} else if(stepPx >= drawThreshold){
			if(leftTicks) painter.drawLine(x, y, x + lineLenghtSmall, y);
			if(rightTicks) painter.drawLine(x + width - lineLenghtSmall, y, x + width, y);
		}

		i++;
	}

	if(!connected){
		int iconDim = 32;
		QIcon icon = style()->standardIcon(QStyle::SP_MessageBoxWarning);
		QPixmap pixmap = icon.pixmap(iconDim,iconDim);
		painter.eraseRect(x+width/2 - (iconDim+4)/2, y + height / 2 - (iconDim+4)/2,
				iconDim+4, iconDim+4);
		painter.drawPixmap(x+width/2 - iconDim/2, y + height / 2 - iconDim/2,
				iconDim, iconDim,
				pixmap,
				0, 0,
				iconDim, iconDim);
	}
}

void VuMeterWidget::paintEvent(QPaintEvent * /*paintEvent*/){
	const int scaleWidth = 30;

	const int meterCount = std::max(1, channels);

	const int meterWidth = (width() - scaleWidth) / meterCount;

	QPainter painter(this);

	if(meterCount % 2 != 0){
		int scaleX = onRightSide ? 0 : meterCount * meterWidth;
		int metersStartX = onRightSide ? scaleWidth : 0;

		for(int i = 0; i < meterCount; i++){
			paintMeter(painter,
					metersStartX + i * meterWidth,
					meterVerticalPad,
					meterWidth,
					height() - meterVerticalPad * 2,
					barLevel[i],
					rmsLevel[i],
					maximumLevel[i].val);
		}

		paintScale(painter,
				scaleX,
				0,
				scaleWidth,
				height(),
				!onRightSide,
				onRightSide);
	} else {
		int i = 0;
		for(; i < meterCount / 2; i++){
			paintMeter(painter,
					i * meterWidth,
					meterVerticalPad,
					meterWidth,
					height() - meterVerticalPad * 2,
					barLevel[i],
					rmsLevel[i],
					maximumLevel[i].val);
		}

		paintScale(painter,
				i * meterWidth,
				0,
				scaleWidth,
				height(),
				true,
				true);

		for(; i < meterCount; i++){
			paintMeter(painter,
					i * meterWidth + scaleWidth,
					meterVerticalPad,
					meterWidth,
					height() - meterVerticalPad * 2,
					barLevel[i],
					rmsLevel[i],
					maximumLevel[i].val);
		}

	}

}