#include "toonzqt/gutil.h"

// TnzQt includes

#include "toonzqt/dvdialog.h"

// TnzCore includes

#include "traster.h"

#include "tpixelutils.h"

#include "tfilepath.h"

#include "tfiletype.h"

#include "tstroke.h"

#include "tcurves.h"

#include "trop.h"

#include "tmsgcore.h"

// Qt includes

#include <qpixmap></qpixmap>

#include <qimage></qimage>

#include <qpainter></qpainter>

#include <qpainterpath></qpainterpath>

#include <qicon></qicon>

#include <qstring></qstring>

#include <qapplication></qapplication>

#include <qmouseevent></qmouseevent>

#include <qtabletevent></qtabletevent>

#include <qkeyevent></qkeyevent>

#include <qurl></qurl>

#include <qfileinfo></qfileinfo>

using namespace DVGui;

//-----------------------------------------------------------------------------

QString fileSizeString(qint64 size, int precision)

{

	if (size < 1024)

		return QString::number(size) + " Bytes";

	else if (size < 1024 * 1024)

		return QString::number(size / (1024.0), 'f', precision) + " KB";

	else if (size < 1024 * 1024 * 1024)

		return QString::number(size / (1024 * 1024.0), 'f', precision) + " MB";

	else

		return QString::number(size / (1024 * 1024 * 1024.0), 'f', precision) + " GB";

}

//----------------------------------------------------------------

QImage rasterToQImage(const TRasterP &ras, bool premultiplied, bool mirrored)

{

	if (TRaster32P ras32 = ras) {

		QImage image(ras->getRawData(), ras->getLx(), ras->getLy(),

					 premultiplied ? QImage::Format_ARGB32_Premultiplied : QImage::Format_ARGB32);

		if (mirrored)

			return image.mirrored();

		return image;

	} else if (TRasterGR8P ras8 = ras) {

		QImage image(ras->getRawData(), ras->getLx(), ras->getLy(), ras->getWrap(), QImage::Format_Indexed8);

		static QVector<qrgb> colorTable;</qrgb>

		if (colorTable.size() == 0) {

			int i;

			for (i = 0; i < 256; i++)

				colorTable.append(QColor(i, i, i).rgb());

		}

		image.setColorTable(colorTable);

		if (mirrored)

			return image.mirrored();

		return image;

	}

	return QImage();

}

//-----------------------------------------------------------------------------

QPixmap rasterToQPixmap(const TRaster32P &ras, bool premultiplied)

{

	QPixmap pixmap;

	return pixmap.fromImage(rasterToQImage(ras, premultiplied));

}

//-----------------------------------------------------------------------------

TRaster32P rasterFromQImage(QImage image, bool premultiply, bool mirror) //no need of const& - Qt uses implicit sharing...

{

	QImage copyImage = mirror ? image.mirrored() : image;

	TRaster32P ras(image.width(), image.height(), image.width(), (TPixelRGBM32 *)copyImage.bits(), false);

	if (premultiply)

		TRop::premultiply(ras);

	return ras->clone();

}

//-----------------------------------------------------------------------------

TRaster32P rasterFromQPixmap(QPixmap pixmap, bool premultiply, bool mirror) //no need of const& - Qt uses implicit sharing...

{

	QImage image = pixmap.toImage();

	return rasterFromQImage(image, premultiply, mirror);

}

//-----------------------------------------------------------------------------

void drawPolygon(QPainter &p,

				 const std::vector<qpointf> &points,</qpointf>

				 bool fill,

				 const QColor colorFill,

				 const QColor colorLine)

{

	if (points.size() == 0)

		return;

	p.setPen(colorLine);

	QPolygonF E0Polygon;

	int i = 0;

	for (i = 0; i < (int)points.size(); i++)

		E0Polygon << QPointF(points[i]);

	E0Polygon << QPointF(points[0]);

	QPainterPath E0Path;

	E0Path.addPolygon(E0Polygon);

	if (fill)

		p.fillPath(E0Path, QBrush(colorFill));

	p.drawPath(E0Path);

}

//-----------------------------------------------------------------------------

void drawArrow(QPainter &p,

			   const QPointF a, const QPointF b, const QPointF c,

			   bool fill,

			   const QColor colorFill,

			   const QColor colorLine)

{

	std::vector<qpointf> pts;</qpointf>

	pts.push_back(a);

	pts.push_back(b);

	pts.push_back(c);

	drawPolygon(p, pts, fill, colorFill, colorLine);

}

//-----------------------------------------------------------------------------

QPixmap scalePixmapKeepingAspectRatio(QPixmap pixmap, QSize size, QColor color)

{

	if (pixmap.isNull() || pixmap.size() == size)

		return pixmap;

	QPixmap scaledPixmap = pixmap.scaled(size.width(), size.height(), Qt::KeepAspectRatio, Qt::SmoothTransformation);

	QPixmap newPixmap(size);

	newPixmap.fill(color);

	QPainter painter(&newPixmap);

	painter.drawPixmap(double(size.width() - scaledPixmap.width()) * 0.5,

					   double(size.height() - scaledPixmap.height()) * 0.5,

					   scaledPixmap);

	return newPixmap;

}

//-----------------------------------------------------------------------------

QIcon createQIcon(const char *iconSVGName)

{

	QString normal = QString(":Resources/") + iconSVGName + ".svg";

	QString click = QString(":Resources/") + iconSVGName + "_click.svg";

	QString over = QString(":Resources/") + iconSVGName + "_over.svg";

	QIcon icon;

	icon.addFile(normal, QSize(), QIcon::Normal, QIcon::Off);

	icon.addFile(click, QSize(), QIcon::Normal, QIcon::On);

	icon.addFile(over, QSize(), QIcon::Active);

	return icon;

}

//-----------------------------------------------------------------------------

QIcon createQIconPNG(const char *iconPNGName)

{

	QString normal = QString(":Resources/") + iconPNGName + ".png";

	QString click = QString(":Resources/") + iconPNGName + "_click.png";

	QString over = QString(":Resources/") + iconPNGName + "_over.png";

	QIcon icon;

	icon.addFile(normal, QSize(), QIcon::Normal, QIcon::Off);

	icon.addFile(click, QSize(), QIcon::Normal, QIcon::On);

	icon.addFile(over, QSize(), QIcon::Active);

	return icon;

}

//-----------------------------------------------------------------------------

QIcon createQIconOnOff(const char *iconSVGName, bool withOver)

{

	QString on = QString(":Resources/") + iconSVGName + "_on.svg";

	QString off = QString(":Resources/") + iconSVGName + "_off.svg";

	QString over = QString(":Resources/") + iconSVGName + "_over.svg";

	QIcon icon;

	icon.addFile(off, QSize(), QIcon::Normal, QIcon::Off);

	icon.addFile(on, QSize(), QIcon::Normal, QIcon::On);

	if (withOver)

		icon.addFile(over, QSize(), QIcon::Active);

	else

		icon.addFile(on, QSize(), QIcon::Active);

	return icon;

}

//-----------------------------------------------------------------------------

QIcon createQIconOnOffPNG(const char *iconPNGName, bool withOver)

{

	QString on = QString(":Resources/") + iconPNGName + "_on.png";

	QString off = QString(":Resources/") + iconPNGName + "_off.png";

	QString over = QString(":Resources/") + iconPNGName + "_over.png";

	QIcon icon;

	icon.addFile(off, QSize(), QIcon::Normal, QIcon::Off);

	icon.addFile(on, QSize(), QIcon::Normal, QIcon::On);

	if (withOver)

		icon.addFile(over, QSize(), QIcon::Active);

	else

		icon.addFile(on, QSize(), QIcon::Active);

	return icon;

}

//-----------------------------------------------------------------------------

QString toQString(const TFilePath &path)

{

	return QString::fromStdWString(path.getWideString());

}

//-----------------------------------------------------------------------------

bool isSpaceString(const QString &str)

{

	int i;

	QString space(" ");

	for (i = 0; i < str.size(); i++)

		if (str.at(i) != space.at(0))

			return false;

	return true;

}

//-----------------------------------------------------------------------------

bool isValidFileName(const QString &fileName)

{

	if (fileName.isEmpty() ||

		fileName.contains(":") ||

		fileName.contains("\\") ||

		fileName.contains("/") ||

		fileName.contains(">") ||

		fileName.contains("<") ||

		fileName.contains("*") ||

		fileName.contains("|") ||

		fileName.contains("\"") ||

		fileName.contains("?") ||

		fileName.trimmed().isEmpty())

		return false;

	return true;

}

//-----------------------------------------------------------------------------

bool isValidFileName_message(const QString &fileName)

{

	return isValidFileName(fileName) ? true : (DVGui::error(QObject::tr("The file name cannot be empty or contain any of the following "

																			"characters: (new line) \\ / : * ? \" |")),

											   false);

}

//-----------------------------------------------------------------------------

QString elideText(const QString &srcText, const QFont &font, int width)

{

	QFontMetrics metrix(font);

	int srcWidth = metrix.width(srcText);

	if (srcWidth < width)

		return srcText;

	int tilde = metrix.width("~");

	int block = (width - tilde) / 2;

	QString text("");

	int i;

	for (i = 0; i < srcText.size(); i++) {

		text += srcText.at(i);

		if (metrix.width(text) > block)

			break;

	}

	text[i] = '~';

	QString endText("");

	for (i = srcText.size() - 1; i >= 0; i--) {

		endText.push_front(srcText.at(i));

		if (metrix.width(endText) > block)

			break;

	}

	endText.remove(0, 1);

	text += endText;

	return text;

}

//-----------------------------------------------------------------------------

QString elideText(const QString &srcText, const QFontMetrics &fm, int width, const QString &elideSymbol)

{

	QString text(srcText);

	for (int i = text.size(); i > 1 && fm.width(text) > width;)

		text = srcText.left(--i).append(elideSymbol);

	return text;

}

//-----------------------------------------------------------------------------

QUrl pathToUrl(const TFilePath &path)

{

	return QUrl::fromLocalFile(QString::fromStdWString(path.getWideString()));

}

//-----------------------------------------------------------------------------

bool isResource(const QString &path)

{

	const TFilePath fp(path.toStdWString());

	TFileType::Type type = TFileType::getInfo(fp);

	return (TFileType::isViewable(type) || type & TFileType::MESH_IMAGE || type == TFileType::AUDIO_LEVEL || type == TFileType::TABSCENE || type == TFileType::TOONZSCENE || fp.getType() == "tpl");

}

//-----------------------------------------------------------------------------

bool isResource(const QUrl &url)

{

	return isResource(url.toLocalFile());

}

//-----------------------------------------------------------------------------

bool isResourceOrFolder(const QUrl &url)

{

	struct locals {

		static inline bool isDir(const QString &path)

		{

			return QFileInfo(path).isDir();

		}

	}; // locals

	const QString &path = url.toLocalFile();

	return (isResource(path) || locals::isDir(path));

}

//-----------------------------------------------------------------------------

bool acceptResourceDrop(const QList<qurl> &urls)</qurl>

{

	int count = 0;

	foreach (const QUrl &url, urls) {

		if (isResource(url))

			++count;

		else

			return false;

	}

	return (count > 0);

}

//-----------------------------------------------------------------------------

bool acceptResourceOrFolderDrop(const QList<qurl> &urls)</qurl>

{

	int count = 0;

	foreach (const QUrl &url, urls) {

		if (isResourceOrFolder(url))

			++count;

		else

			return false;

	}

	return (count > 0);

}

//-----------------------------------------------------------------------------

QPainterPath strokeToPainterPath(TStroke *stroke)

{

	QPainterPath path;

	int i, chunkSize = stroke->getChunkCount();

	for (i = 0; i < chunkSize; i++) {

		const TThickQuadratic *q = stroke->getChunk(i);

		if (i == 0)

			path.moveTo(toQPointF(q->getThickP0()));

		path.quadTo(toQPointF(q->getThickP1()), toQPointF(q->getThickP2()));

	}

	return path;

}

//=============================================================================

// TabBarContainter

//-----------------------------------------------------------------------------

TabBarContainter::TabBarContainter(QWidget *parent)

	: QFrame(parent)

{

	setObjectName("TabBarContainer");

	setFrameStyle(QFrame::StyledPanel);

}

//-----------------------------------------------------------------------------

void TabBarContainter::paintEvent(QPaintEvent *event)

{

	QPainter p(this);

	p.setPen(QColor(120, 120, 120));

	p.drawLine(0, height() - 2, width(), height() - 2);

	p.setPen(Qt::white);

	p.drawLine(0, height() - 1, width(), height() - 1);

}

//=============================================================================

// ToolBarContainer

//-----------------------------------------------------------------------------

ToolBarContainer::ToolBarContainer(QWidget *parent)

	: QFrame(parent)

{

	setObjectName("ToolBarContainer");

	setFrameStyle(QFrame::StyledPanel);

	setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);

}

//-----------------------------------------------------------------------------

void ToolBarContainer::paintEvent(QPaintEvent *event)

{

	QPainter p(this);

	p.setPen(QColor(120, 120, 120));

	p.drawLine(0, 0, width(), 0);

}

//=============================================================================

QString operator+(const QString &a, const TFilePath &fp)

{

	return a + QString::fromStdWString(fp.getWideString());

}