#include "tcolorstyles.h"

#include <qvboxlayout></qvboxlayout>

#include <qcombobox></qcombobox>

#include <qpushbutton></qpushbutton>

#include <qicon></qicon>

#include <qstackedwidget></qstackedwidget>

#include <qpainter></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;</int>

	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));</histogramview>

	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();

}