#include "tcolorstyles.h"
 
#include <QVBoxLayout>
#include <QComboBox>
#include <QPushButton>
#include <QIcon>
#include <QStackedWidget>
#include <QPainter>
 
#include "toonzqt/histogram.h"
 
const int HistogramGraph::drawMargin = 10;
 
//*****************************************************************************
//    Local namespace
//*****************************************************************************
 
namespace
{
 
void computeGreyValues(const TRasterGR8P &ras, int *greyValues)
{
	int y, lx = ras->getLx(), ly = ras->getLy();
	TPixelGR8 *pix, *endPix;
 
	for (y = 0; y < ly; ++y)
		for (pix = ras->pixels(y), endPix = pix + lx; pix < endPix; ++pix)
			++greyValues[pix->value];
}
 
//-----------------------------------------------------------------------------
 
void computeGreyValues(const TRasterGR16P &ras, int *greyValues)
{
	int y, lx = ras->getLx(), ly = ras->getLy();
	TPixelGR16 *pix, *endPix;
 
	for (y = 0; y < ly; ++y)
		for (pix = ras->pixels(y), endPix = pix + lx; pix < endPix; ++pix)
			++greyValues[pix->value >> 8];
}
 
//-----------------------------------------------------------------------------
 
void computeRGBMValues32(const TRaster32P &ras, int (*rgbmValues)[256])
{
	int y, lx = ras->getLx(), ly = ras->getLy();
	TPixel32 *pix, *endPix;
 
	for (y = 0; y < ly; ++y)
		for (pix = ras->pixels(y), endPix = pix + lx; pix < endPix; ++pix) {
			//NOTE: The insertion order is related to the way channels are
			//displayed inside the histogram's QStackedWidget instance
			if (pix->m) {
				++rgbmValues[0][pix->r];
				++rgbmValues[1][pix->g];
				++rgbmValues[2][pix->b];
			}
			++rgbmValues[3][pix->m];
		}
}
 
//-----------------------------------------------------------------------------
 
void computeRGBMValues64(const TRaster64P &ras, int (*rgbmValues)[256])
{
	int y, lx = ras->getLx(), ly = ras->getLy();
	TPixel64 *pix, *endPix;
 
	for (y = 0; y < ly; ++y)
		for (pix = ras->pixels(y), endPix = pix + lx; pix < endPix; ++pix) {
			//NOTE: The insertion order is related to the way channels are
			//displayed inside the histogram's QStackedWidget instance
			if (pix->m) {
				++rgbmValues[0][pix->r >> 8];
				++rgbmValues[1][pix->g >> 8];
				++rgbmValues[2][pix->b >> 8];
			}
			++rgbmValues[3][pix->m >> 8];
		}
}
 
//-----------------------------------------------------------------------------
 
void computeRGBMValues(const TRasterCM32P &ras, TPaletteP pal, int (*rgbmValues)[256])
{
	assert(pal);
 
	int y, lx = ras->getLx(), ly = ras->getLy();
	TPixelCM32 *pix, *endPix;
 
	int styleId;
	TColorStyle *colorStyle;
	TPixel32 color;
 
	for (y = 0; y < ly; ++y)
		for (pix = ras->pixels(y), endPix = pix + lx; pix < endPix; ++pix) {
			styleId = (pix->getTone() < 127) ? pix->getInk() : pix->getPaint();
			colorStyle = pal->getStyle(styleId);
			if (!colorStyle)
				continue;
 
			color = colorStyle->getAverageColor();
			if (color.m) {
				++rgbmValues[0][color.r];
				++rgbmValues[1][color.g];
				++rgbmValues[2][color.b];
			}
			++rgbmValues[3][color.m];
		}
}
 
//-----------------------------------------------------------------------------
 
void computeRGB(int (*channelValues)[256], int *rgbValues)
{
	int i;
	for (i = 0; i < 256; ++i)
		rgbValues[i] = channelValues[0][i] + channelValues[1][i] + channelValues[2][i];
}
 
//-----------------------------------------------------------------------------
 
void computeRGBM(int (*channelValues)[256], int *rgbmValues)
{
	int i;
	for (i = 0; i < 256; ++i)
		rgbmValues[i] =
			channelValues[0][i] + channelValues[1][i] +
			channelValues[2][i] + channelValues[3][i];
}
 
} //namespace
 
//=============================================================================
// HistogramGraph
//-----------------------------------------------------------------------------
 
HistogramGraph::HistogramGraph(QWidget *parent, QColor color)
	: QWidget(parent), m_color(color), m_height(120), m_values(0), m_logScale(false)
{
	if (m_color.alpha() == 0)
		m_color = Qt::black;
 
	setMinimumWidth(256 + drawMargin * 2 + 2);
	setMinimumHeight(m_height + drawMargin);
}
 
//-----------------------------------------------------------------------------
 
HistogramGraph::~HistogramGraph()
{
	m_values.clear();
}
 
//-----------------------------------------------------------------------------
 
void HistogramGraph::setAlphaMask(int value)
{
	m_color.setAlpha(value);
}
 
//-----------------------------------------------------------------------------
 
void HistogramGraph::setValues(const int values[])
{
	m_values.clear();
	m_values.resize(256);
 
	int i;
 
	double maxValue = 0;
	for (i = 0; i < 256; i++) {
		int count = m_values[i] = values[i];
		if (maxValue < count)
			maxValue = count;
	}
 
	m_viewValues.clear();
	m_logViewValues.clear();
	m_viewValues.resize(256);
	m_logViewValues.resize(256);
 
	double logMaxValue = log(1.0 + maxValue);
 
	for (i = 0; i < 256; i++) {
		m_viewValues[i] = double(values[i]) * double(m_height) / maxValue;
		m_logViewValues[i] = double(log(1.0 + values[i])) * double(m_height) / logMaxValue;
	}
}
 
//-----------------------------------------------------------------------------
 
void HistogramGraph::draw(QPainter *p, QPoint translation)
{
	int x0 = translation.x() + drawMargin;
	int y0 = translation.y() + drawMargin - 2;
	int w = width() - 2 * drawMargin;
	int h = m_height + 1;
 
	p->setPen(Qt::NoPen);
	p->setBrush(Qt::white);
	p->drawRect(x0, y0, w - 1, h);
	p->setBrush(Qt::NoBrush);
 
	p->setPen(Qt::gray);
	int step = w * 0.25;
	int deltaX = x0 + 1 + step;
	int y1 = y0 + h;
	p->drawLine(deltaX, y0 + 1, deltaX, y1);
	deltaX += step;
	p->drawLine(deltaX, y0 + 1, deltaX, y1);
	deltaX += step;
	p->drawLine(deltaX, y0 + 1, deltaX, y1);
 
	p->drawRect(x0, y0, w - 1, h);
 
	if (m_values.size() == 0)
		return;
 
	const QVector<int> &viewValues = m_logScale ? m_logViewValues : m_viewValues;
 
	p->setPen(m_color);
	w = w - 2;
	x0 = x0 + 1;
	y1 = y1 - 1;
	int i;
	double gap = double(viewValues.size()) / double(w); /*-- 1チャンネル値あたりのグラフの横幅 --*/
	for (i = 0; i < w; i++) {
		int j = i * gap;
		assert(j >= 0 && j < viewValues.size());
		int v = viewValues[j];
		if (v <= 0)
			continue;
		int x = x0 + i;
		p->drawLine(x, y1 - v + 1, x, y1);
	}
}
 
//-----------------------------------------------------------------------------
 
void HistogramGraph::paintEvent(QPaintEvent *event)
{
	QPainter p(this);
	draw(&p);
}
 
//=============================================================================
// ChannelBar
//-----------------------------------------------------------------------------
 
ChannelBar::ChannelBar(QWidget *parent, QColor color, bool isHorizontal)
	: QWidget(parent), m_color(color), m_isHorizontal(isHorizontal), m_colorBarLength(13), m_drawNumbers(true)
{
	int d = 256 + HistogramGraph::drawMargin * 2 + 2;
 
	if (m_isHorizontal)
		setMinimumWidth(d);
	else
		setFixedHeight(d); //La barra verticale ha la size fissa
 
	setDrawNumbers(m_drawNumbers);
 
	if (color == Qt::black)
		m_color = Qt::white;
}
 
//-----------------------------------------------------------------------------
 
ChannelBar::~ChannelBar()
{
}
 
//-----------------------------------------------------------------------------
 
void ChannelBar::setDrawNumbers(bool onOff)
{
	if (m_isHorizontal)
		setFixedHeight(onOff ? m_colorBarLength * 2 + 2 : m_colorBarLength + 2);
	else
		setFixedWidth(onOff ? m_colorBarLength + 20 + 2 : m_colorBarLength + 2);
}
 
//-----------------------------------------------------------------------------
 
void ChannelBar::draw(QPainter *p, QPoint translation)
{
	//Calcolo i parametri necessari al draw a seconda del caso in cui mi trovo.
	int space = HistogramGraph::drawMargin;
	int w, h, x0, y0;
	QRect rect;
	QPoint initialPoint, finalPoint, delta;
	QColor initialColor, finalColor;
	if (m_isHorizontal) {
		w = width() - 2 * HistogramGraph::drawMargin;
		h = m_colorBarLength;
		x0 = translation.x() + space;
		y0 = translation.y();
		initialPoint = QPoint(x0, 0);
		finalPoint = QPoint(w + x0, 0);
		initialColor = Qt::black;
		finalColor = m_color;
		rect = QRect(x0 - space, y0 + h, 20, 20);
		delta = QPoint(w / 4, 0);
	} else {
		w = m_colorBarLength;
		h = height() - 2 * HistogramGraph::drawMargin;
		x0 = translation.x() + width() - w;
		y0 = translation.y() + space;
		initialPoint = QPoint(0, y0);
		finalPoint = QPoint(0, h + y0);
		initialColor = m_color;
		finalColor = Qt::black;
		rect = QRect(0, h + y0 - space, 20, 20);
		delta = QPoint(0, -h / 4);
	}
 
	if (m_color == QColor(0, 0, 0, 0)) {
		static QPixmap checkboard(":Resources/backg.png");
		p->drawTiledPixmap(x0, y0, w, h, checkboard);
		QColor color = initialColor;
		initialColor = finalColor;
		finalColor = color;
	}
 
	QLinearGradient linearGrad(initialPoint, finalPoint);
	linearGrad.setColorAt(0, initialColor);
	linearGrad.setColorAt(1, finalColor);
 
	p->setBrush(QBrush(linearGrad));
 
	p->setPen(Qt::black);
	p->drawRect(x0, y0, w - 1, h - 1);
 
	if (m_drawNumbers) {
		p->drawText(rect, Qt::AlignCenter, QString::number(0));
		rect.translate(delta);
		p->drawText(rect, Qt::AlignCenter, QString::number(64));
		rect.translate(delta);
		p->drawText(rect, Qt::AlignCenter, QString::number(128));
		rect.translate(delta);
		p->drawText(rect, Qt::AlignCenter, QString::number(192));
		rect.translate(delta);
		p->drawText(rect, Qt::AlignCenter, QString::number(255));
	}
}
 
//-----------------------------------------------------------------------------
 
void ChannelBar::paintEvent(QPaintEvent *event)
{
	QPainter p(this);
	draw(&p);
}
 
//=============================================================================
// HistogramView
//-----------------------------------------------------------------------------
 
HistogramView::HistogramView(QWidget *parent, QColor color)
	: QWidget(parent), m_drawnWidget(parent)
{
	setMinimumWidth(256 + 10 * 2 + 2);  //10 == margin of internal widget
	setMinimumHeight(120 + 10 * 2 + 2); //10 == margin of internal widget
 
	QVBoxLayout *mainLayout = new QVBoxLayout(this);
	mainLayout->setMargin(0);
	mainLayout->setSpacing(7);
 
	m_histogramGraph = new HistogramGraph(this, color);
	m_colorBar = new ChannelBar(this, color);
 
	mainLayout->addWidget(m_histogramGraph);
	mainLayout->addWidget(m_colorBar);
 
	setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
	setLayout(mainLayout);
}
 
//-----------------------------------------------------------------------------
 
void HistogramView::setDrawnWidget(QWidget *widget)
{
	m_drawnWidget = widget;
}
 
//-----------------------------------------------------------------------------
 
void HistogramView::setValues(const int values[])
{
	m_histogramGraph->setValues(values);
	m_drawnWidget->update();
}
 
//-----------------------------------------------------------------------------
 
void HistogramView::draw(QPainter *painter, QPoint translation)
{
	m_histogramGraph->draw(painter, translation);
	m_colorBar->draw(painter, QPoint(translation.x(), translation.y() + m_histogramGraph->getHeight() + 17));
}
 
//-----------------------------------------------------------------------------
 
HistogramView::~HistogramView()
{
}
 
//=============================================================================
// Histograms
//-----------------------------------------------------------------------------
 
Histograms::Histograms(QWidget *parent, bool rgba)
	: QStackedWidget(parent), m_raster(0), m_palette(0), m_computeAlsoRGBA(rgba), m_channelsCount(rgba ? 6 : 5)
{
	setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
 
	HistogramView *histogramViews[6];
 
	int h = 0;
	if (m_computeAlsoRGBA)
		histogramViews[h++] = new HistogramView(this);
 
	histogramViews[h++] = new HistogramView(this);
	histogramViews[h++] = new HistogramView(this, Qt::red);
	histogramViews[h++] = new HistogramView(this, Qt::green);
	histogramViews[h++] = new HistogramView(this, Qt::blue);
	histogramViews[h++] = new HistogramView(this, QColor(0, 0, 0, 0));
 
	int i;
	for (i = 0; i < m_channelsCount; ++i)
		addWidget(histogramViews[i]);
}
 
//-----------------------------------------------------------------------------
 
Histograms::~Histograms()
{
	memset(m_channelValue, 0, sizeof m_channelValue);
}
 
//-----------------------------------------------------------------------------
 
void Histograms::setRaster(const TRasterP &raster, const TPaletteP &palette)
{
	if (palette.getPointer())
		m_palette = palette;
	m_raster = raster;
	computeChannelsValue();
	int i;
	for (i = 0; i < count(); i++)
		getHistogramView(i)->setValues(m_channelValue[i]);
}
 
//-----------------------------------------------------------------------------
 
void Histograms::computeChannelsValue()
{
	m_channelsCount = m_computeAlsoRGBA ? 6 : 5;
 
	memset(m_channelValue, 0, sizeof m_channelValue);
	if (!m_raster.getPointer())
		return;
 
	int(*rgbChannelValues)[256] = m_channelValue + (m_computeAlsoRGBA ? 1 : 0);
	int(*channelValues)[256] = rgbChannelValues + 1;
 
	TRasterCM32P cmRaster = m_raster;
	bool isCmRaster = !!cmRaster;
 
	{
		TRaster32P ras32(m_raster);
		if (ras32) {
			::computeRGBMValues32(ras32, channelValues);
			goto computeChannelsSums;
		}
	}
 
	{
		TRaster64P ras64(m_raster);
		if (ras64) {
			::computeRGBMValues64(ras64, channelValues);
			goto computeChannelsSums;
		}
	}
 
	{
		TRasterGR8P rasGR8(m_raster);
		if (rasGR8) {
			m_channelsCount = 1;
			::computeGreyValues(rasGR8, m_channelValue[0]);
			return;
		}
	}
 
	{
		TRasterGR16P rasGR16(m_raster);
		if (rasGR16) {
			m_channelsCount = 1;
			::computeGreyValues(rasGR16, m_channelValue[0]);
			return;
		}
	}
 
	return;
 
computeChannelsSums:
 
	if (m_computeAlsoRGBA)
		::computeRGBM(channelValues, m_channelValue[0]);
	::computeRGB(channelValues, *rgbChannelValues);
}
 
//-----------------------------------------------------------------------------
 
HistogramView *Histograms::getHistogramView(int indexType) const
{
	HistogramView *ch = dynamic_cast<HistogramView *>(widget(indexType));
	assert(ch);
	return ch;
}
 
//=============================================================================
// Histogram
//-----------------------------------------------------------------------------
 
Histogram::Histogram(QWidget *parent)
	: QWidget(parent)
{
	setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
 
	QVBoxLayout *mainLayout = new QVBoxLayout(this);
	mainLayout->setMargin(0);
	mainLayout->setSpacing(0);
	setLayout(mainLayout);
 
	QHBoxLayout *upperLayout = new QHBoxLayout;
	mainLayout->addLayout(upperLayout);
 
	m_channelsListBox = new QComboBox(this);
	m_channelsListBox->setFixedSize(100, 20);
 
	upperLayout->addSpacing(HistogramGraph::drawMargin);
	upperLayout->addWidget(m_channelsListBox);
	upperLayout->addStretch(1);
 
	QIcon icon;
 
	QString normal = QString(":Resources/histograms.png");
	QString click = QString(":Resources/histograms_over.png");
 
	icon.addFile(normal, QSize(), QIcon::Normal, QIcon::Off);
	icon.addFile(click, QSize(), QIcon::Normal, QIcon::On);
 
	QPushButton *logScaleButton = new QPushButton(icon, "", this);
	logScaleButton->setToolTip(tr("Logarithmic Scale"));
	logScaleButton->setFixedSize(20, 20);
	logScaleButton->setCheckable(true);
 
	upperLayout->addWidget(logScaleButton);
	upperLayout->addSpacing(HistogramGraph::drawMargin);
 
	m_histograms = new Histograms(this);
	m_histograms->setCurrentIndex(0);
	mainLayout->addWidget(m_histograms);
 
	connect(m_channelsListBox, SIGNAL(currentIndexChanged(int)), m_histograms, SLOT(setCurrentIndex(int)));
	connect(logScaleButton, SIGNAL(toggled(bool)), this, SLOT(setLogScale(bool)));
 
	updateChannelsList();
}
 
//-----------------------------------------------------------------------------
 
void Histogram::updateChannelsList()
{
	if (m_histograms->channelsCount() != m_channelsListBox->count()) {
		QStringList channels;
		m_channelsListBox->clear();
 
		if (m_histograms->channelsCount() == 1)
			channels << "Value";
		else
			channels << "RGB"
					 << "Red"
					 << "Green"
					 << "Blue"
					 << "Alpha";
 
		m_channelsListBox->addItems(channels);
	}
}
 
//-----------------------------------------------------------------------------
 
void Histogram::setRaster(const TRasterP &raster, const TPaletteP &palette)
{
	m_histograms->setRaster(raster, palette);
	updateChannelsList();
}
 
//-----------------------------------------------------------------------------
 
void Histogram::setLogScale(bool onOff)
{
	int i, count = m_histograms->channelsCount();
	for (i = 0; i < count; ++i) {
		HistogramGraph *graph = m_histograms->getHistogramView(i)->histogramGraph();
		graph->setLogScale(onOff);
	}
	update();
}