/***************************************************************************
 *   Copyright (C) 2008 by Oliver Groß                                     *
 *   z.o.gross@gmx.de                                                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include "ccrossfieldwidget.h"

#include <libqnono/cnonogram.h>

#include <QPainter>
#include <QMouseEvent>
#include <QLCDNumber>
#include <QDebug>
#include <QFrame>
#include <QLabel>
#include <QHBoxLayout>
#include <QStyle>
#include <QApplication>

namespace qcross {
	using namespace libqnono;

	int min(int a, int b) {
		return (a < b) ? a : b;
	}
	
	int max(int a, int b) {
		return (a > b) ? a : b;
	}
	
	//public
	CCrossFieldWidget::CCrossFieldWidget(QWidget * parent) : QWidget(parent),
		m_MessageTimeoutId(-1),
		m_Nonogram(new CNonogram(this)),
		m_MouseMark(NonogramMarker::NONE),
		m_MouseDown(false),
		m_NumbersMarkable(true),
		m_Clock(new QLCDNumber(8, this)),
		m_LastErrorMark(-1, -1)
	{
// 		m_Notifier = new QFrame(this);
// 		m_Notifier->setLineWidth(10);
// 		m_Notifier->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
		QPalette notifierPalette(QApplication::palette().color(QPalette::ToolTipBase));
		notifierPalette.setColor(QPalette::Text, QApplication::palette().color(QPalette::ToolTipText));
		
// 		m_Notifier->setPalette(notifierPalette);
// 		m_Notifier->setAutoFillBackground(true);
		
// 		QHBoxLayout * notifierLayout = new QHBoxLayout(m_Notifier);
// 		m_NotifierIcon = new QLabel(m_Notifier);
// 		m_NotifierText = new QLabel(m_Notifier);
		
// 		m_NotifierText->setWordWrap(true);
// 		notifierLayout->addWidget(m_NotifierIcon);
// 		notifierLayout->addWidget(m_NotifierText);
// 		notifierLayout->addStretch();
// 		m_Notifier->setLayout(notifierLayout);
		
// 		m_Notifier->hide();
		
		m_Clock->setVisible(false);
		
		setEnabled(false);
		
		connect(m_Nonogram, SIGNAL(loaded()), SLOT(loaded()));
		connect(m_Nonogram, SIGNAL(won(int)), SLOT(won(int)));
		connect(m_Nonogram, SIGNAL(timeup()), SLOT(timeup()));
		connect(m_Nonogram, SIGNAL(wrongMark(int,int,int)), SLOT(wrongMark(int,int,int)));
		connect(m_Nonogram, SIGNAL(changedMark(int,int)), SLOT(changedMark(int,int)));
		connect(m_Nonogram, SIGNAL(restarted()), SLOT(restarted()));
		connect(m_Nonogram, SIGNAL(paused(int)), SLOT(paused(int)));
		connect(m_Nonogram, SIGNAL(resumed(int)), SLOT(resumed(int)));
		connect(m_Nonogram, SIGNAL(tick(int)), SLOT(tick(int)));
	}
	
	CCrossFieldWidget::~CCrossFieldWidget() {
		qDebug("m_MessageTimeoutId = %i", m_MessageTimeoutId);
		if (m_MessageTimeoutId != -1) {
			killTimer(m_MessageTimeoutId);
			m_MessageTimeoutId = -1;
		}
	}
	
	void CCrossFieldWidget::showMessage(const QString message, int timeout, MessageType type) {
		if (!message.isEmpty()) {
			Message newMessage;
			newMessage.type = type;
			newMessage.text = message;
			newMessage.timeout = timeout;
			m_Messages.enqueue(newMessage);
		}
		
		if (m_MessageTimeoutId == -1)
			nextMessage();
	}
	
	//public slots
	void CCrossFieldWidget::setNumbersMarkable(bool value) {
		m_NumbersMarkable = value;
	}
	
	//protected slots:
	void CCrossFieldWidget::loaded() {
		m_LastErrorMark = QPoint(-1, -1);
		initialize();
		updateTimeDisplay();
		m_Messages.clear();
		if (m_Nonogram->valid()) {
			if (m_Nonogram->time() == m_Nonogram->timeout()) {
				showMessage(tr("Game started!"), 1000);
			} else {
				showMessage(tr("Save game loaded!"), 1000);
			}
			setEnabled(true);
		} else {
			nextMessage();
			setEnabled(false);
		}
	}
	
	void CCrossFieldWidget::won(int score) {
		showMessage(tr("Congratulations! You've solved the puzzle."));
	}
	
	void CCrossFieldWidget::timeup() {
		showMessage(tr("Too bad! Time's up."), 0, CCrossFieldWidget::Critical);
	}
	
	void CCrossFieldWidget::wrongMark(int x, int y, int penaltyTime) {
		m_LastErrorMark = QPoint(x, y);
		showMessage(tr("Sorry this was not correct: -%1min").arg(penaltyTime/60), 1000, CCrossFieldWidget::Warning);
	}
	
	void CCrossFieldWidget::changedMark(int x, int y) {
		update();
	}
	
	void CCrossFieldWidget::restarted() {
		m_Messages.clear();
		m_LastErrorMark = QPoint(-1, -1);
		showMessage(tr("Game restarted."), 1000);
	}
	
	void CCrossFieldWidget::paused(int time) {
		if (m_Message.type != Invalid) {
			m_Messages.enqueue(m_Message);
			
			if (m_MessageTimeoutId != -1) {
				killTimer(m_MessageTimeoutId);
				m_MessageTimeoutId = -1;
			}
		}
		setEnabled(false);
		showMessage(tr("Game paused."));
	}
	
	void CCrossFieldWidget::resumed(int time) {
		setEnabled(true);
		showMessage(tr("Game resumed."), 1000);
		update();
	}
	
	void CCrossFieldWidget::tick(int time) {
		updateTimeDisplay();
	}
	
	//protected
	void CCrossFieldWidget::nextMessage() {
		if (m_MessageTimeoutId != -1)
			killTimer(m_MessageTimeoutId);
		
		m_MessageTimeoutId = -1;
		
		if (m_Messages.isEmpty()) {
			m_Message.type = Invalid;
// 			m_Notifier->hide();
// 			updateMetrics();
			update();
			return;
		}
		
		m_Message = m_Messages.dequeue();
		update();
		
/*		switch (m_Message.type) {
		case Information:
			m_NotifierIcon->setPixmap(style()->standardIcon(QStyle::SP_MessageBoxInformation).pixmap(22, 22));
			break;
		case Warning:
			m_NotifierIcon->setPixmap(style()->standardIcon(QStyle::SP_MessageBoxWarning).pixmap(22, 22));
			break;
		case Critical:
			m_NotifierIcon->setPixmap(style()->standardIcon(QStyle::SP_MessageBoxCritical).pixmap(22, 22));
			break;
		default:
			break;
		}
		
		m_NotifierText->setText(m_Message.text);
		
		m_Notifier->show();
		updateMetrics();*/
		
		if (m_Message.timeout)
			m_MessageTimeoutId = startTimer(m_Message.timeout);
	}
	
	void CCrossFieldWidget::initialize() {
		int minimumW = max(m_Nonogram->numbers().maximumNumberCount()+1, 5);
		int minimumH = minimumW;
		
		minimumW += m_Nonogram->width();
		minimumH += m_Nonogram->height();
		
		int minimumBoxSize = max(fontMetrics().width(QString::number(m_Nonogram->height())), fontMetrics().width(QString::number(m_Nonogram->width())));
		minimumBoxSize = max(minimumBoxSize, fontInfo().pixelSize() * 1.5);
		
		minimumW *= minimumBoxSize;
		minimumH *= minimumBoxSize;
		
		setMinimumSize(minimumW, minimumH);
		updateMetrics();
	}
	
	void CCrossFieldWidget::timerEvent(QTimerEvent * event) {
		if (event->timerId() == m_MessageTimeoutId) {
			nextMessage();
		}
	}
	
	void CCrossFieldWidget::updateTimeDisplay() {
		m_Clock->setVisible(m_Nonogram->valid());
		
		int secs = m_Nonogram->time();
		quint8 seconds = secs % 60;
		quint8 minutes = secs / 60;
		quint8 hours = minutes / 60;
		minutes %= 60;
		
		QString time("");
		
		if (hours)
			time += QString::number(hours) + ':';
		
		if (minutes < 10)
			time += '0';
		
		time += QString::number(minutes) + ':';
		
		if (seconds < 10)
			time += '0';
		
		time += QString::number(seconds);
		
		m_Clock->display(time);
	}
	
	void CCrossFieldWidget::paintEvent(QPaintEvent *) {
		if (!m_Nonogram) {
			return;
		}
		
		QPainter painter(this);
		
		int originX = m_OffsetX + m_HeaderWidth;
		int originY = m_OffsetY + m_HeaderHeight;
		
		int gridWidth  = m_RasterWidth - m_HeaderWidth;
		int gridHeight = m_RasterHeight - m_HeaderHeight;
		
		// draw background
		{
			const int delta = 5 * m_BoxSize;
			
			int offsetX = 0;
			int offsetY;
			int deltaX = delta;
			int deltaY;
			
			bool useBaseX;
			bool useBaseY = true;
			
			while (offsetX < gridWidth) {
				if (gridWidth - offsetX < delta)
					deltaX = gridWidth - offsetX;
				
				offsetY = 0;
				deltaY = delta;
				
				useBaseX = useBaseY;
				while (offsetY < gridHeight) {
					if (gridHeight - offsetY < delta)
						deltaY = gridHeight - offsetY;
					
					painter.fillRect(originX + offsetX, originY + offsetY, deltaX, deltaY,
						palette().color(useBaseX ? QPalette::Base : QPalette::AlternateBase));
					
					useBaseX = !useBaseX;
					
					offsetY += deltaY;
				}
				
				useBaseY = !useBaseY;
				
				offsetX += deltaX;
			}
		}
		
		// draw markers and crosses
		{
			QPen pen;
			pen.setWidth(m_MarkerSize / 8);
			painter.setPen(pen);
			
			QRectF markerRect(m_MarkerOffset, m_MarkerOffset, m_MarkerSize, m_MarkerSize);
			
			QColor markerColor = palette().color(QPalette::Highlight);
			QColor errorColor = markerColor;
			errorColor.setAlpha(128);
			
			painter.setBrush(markerColor);
			for (int i = 0; i < m_Nonogram->width(); i++) {
				originX = m_OffsetX + m_HeaderWidth + i * m_BoxSize;
				markerRect.moveLeft(originX + m_MarkerOffset);
				
				for (int j = 0; j < m_Nonogram->height(); j++) {
					originY = m_OffsetY + m_HeaderHeight + j * m_BoxSize;
					markerRect.moveTop(originY + m_MarkerOffset);
					
					switch (m_Nonogram->marker().pixel(i, j)) {
					case NonogramMarker::MARKED:
						painter.fillRect(markerRect, painter.brush());
						break;
					case NonogramMarker::CROSSED:
						if (m_Nonogram->isFinished())
							break;
						
						if (i == m_LastErrorMark.x() && j == m_LastErrorMark.y()) {
							painter.setBrush(errorColor);
							painter.fillRect(markerRect, painter.brush());
							painter.setBrush(markerColor);
						}
						
						painter.drawLine(markerRect.topLeft(), markerRect.bottomRight());
						painter.drawLine(markerRect.bottomLeft(), markerRect.topRight());
						break;
					default:
						break;
					}
				}
			}
		}
		
		// draw grid lines
		painter.setPen(palette().color(QPalette::Dark));
		
		for (int i = m_OffsetX + m_HeaderWidth; i < m_OffsetX + m_RasterWidth; i += m_BoxSize) {
			painter.drawLine(i, m_OffsetY + m_HeaderHeight, i, m_OffsetY + m_RasterHeight-1);
		}
		
		for (int i = m_OffsetY + m_HeaderHeight; i < m_OffsetY + m_RasterHeight; i += m_BoxSize) {
			painter.drawLine(m_OffsetX + m_HeaderWidth, i, m_OffsetX + m_RasterWidth-1, i);
		}
		
		// draw numbers area
		if (m_Nonogram->isPaused())
			painter.setPen(palette().color(QPalette::Shadow));
		
		QFont font = painter.font();
		font.setPixelSize(m_MarkerSize * 0.9);
		
		painter.setFont(font);
		
		for (int i = 0; i < m_Nonogram->width(); i++) {
			originX = m_OffsetX + m_HeaderWidth + i * m_BoxSize;
			painter.fillRect(originX, m_OffsetY, m_BoxSize, m_HeaderHeight, palette().color((i % 2) ? QPalette::AlternateBase : QPalette::Base));
			if (!m_Nonogram->isPaused()) {
				painter.setPen(palette().color(QPalette::WindowText));
				int j = m_Nonogram->numbers().columns()[i].count();;
				foreach (quint16 block, m_Nonogram->numbers().columns()[i]) {
					originY = m_OffsetY + m_HeaderHeight - j * m_BoxSize;
					
					painter.drawText(originX, originY, m_BoxSize, m_BoxSize,
						Qt::AlignVCenter | Qt::AlignCenter, QString::number(block));
					--j;
				}
				painter.setPen(palette().color(QPalette::Shadow));
			}
			if (!(i % 5))
				painter.drawLine(originX, m_OffsetY, originX, m_OffsetY + m_RasterHeight-1);
		}
// 		painter.drawLine(m_OffsetX + m_RasterWidth, m_OffsetY, m_OffsetX + m_RasterWidth, m_OffsetY + m_RasterHeight);
		
		for (int i = 0; i < m_Nonogram->height(); i++) {
			originY = m_OffsetY + m_HeaderHeight + i * m_BoxSize;
			painter.fillRect(m_OffsetX, originY, m_HeaderWidth, m_BoxSize, palette().color((i % 2) ? QPalette::AlternateBase : QPalette::Base));
			if (!m_Nonogram->isPaused()) {
				painter.setPen(palette().color(QPalette::WindowText));
				int j = m_Nonogram->numbers().rows()[i].count();
				foreach (quint16 block, m_Nonogram->numbers().rows()[i]) {
					originX = m_OffsetX + m_HeaderWidth - j * m_BoxSize;
					painter.drawText(originX, originY, m_BoxSize, m_BoxSize,
						Qt::AlignVCenter | Qt::AlignCenter, QString::number(block));
					--j;
				}
				painter.setPen(palette().color(QPalette::Shadow));
			}
			if (!(i % 5))
				painter.drawLine(m_OffsetX, originY, m_OffsetX + m_RasterWidth-1, originY);
		}
		
		// draw message if needed
		if (m_Message.type != Invalid) {
			QRect boxrect(m_HeaderWidth + m_OffsetX, m_HeaderHeight + m_OffsetY, m_RasterWidth - m_HeaderWidth, m_RasterHeight - m_HeaderHeight);
			
			QColor fillColor = palette().color(QPalette::Base);
			fillColor.setAlpha(220);
			painter.fillRect(boxrect, fillColor);
			
			font.setPixelSize(font.pixelSize() * 2);
			
			painter.setFont(font);
			painter.drawText(boxrect, Qt::AlignVCenter | Qt::AlignCenter | Qt::TextWordWrap, m_Message.text);
		}
	}
	
/*	void CCrossFieldWidget::updateCell(int x, int y) {
		QPainter painter(this);
		int originX, originY;
		originX = m_OffsetX + m_HeaderWidth + x * m_BoxSize;
		originY = m_OffsetY + m_HeaderHeight + y * m_BoxSize;
		painter.fillRect(originX + 1, originY + 1, m_BoxSize - 2, m_BoxSize - 2, palette().color(QPalette::Base));
		switch (m_OverlayData[x][y]) {
		case CMT_MARKED:
			painter.drawRect(originX + 2, originY + 2, m_BoxSize - 4, m_BoxSize - 4);
			break;
		case CMT_CROSSED:
			painter.drawLine(originX + 2, originY + 2, originX + m_BoxSize - 2, originY + m_BoxSize - 2);
			painter.drawLine(originX + 2, originY + m_BoxSize - 2, originX + m_BoxSize - 2, originY + 2);
			break;
		default:
			break;
		}
	}*/
	
	void CCrossFieldWidget::resizeEvent(QResizeEvent * /*event*/) {
		updateMetrics();
	}
	
	void CCrossFieldWidget::updateMetrics() {
		m_HeaderWidth = max(m_Nonogram->numbers().maximumNumberCount()+1, 5);
/*		m_HeaderWidth = max(m_Picture->width() / 2 + 1, m_Picture->height() / 2 + 1);
		m_HeaderWidth  = m_Picture->width() / 2 + 1;
		m_HeaderHeight = m_Picture->height() / 2 + 1;*/
		
		int fieldsize = min((m_Nonogram->width() + m_HeaderWidth), (m_Nonogram->height() + m_HeaderWidth));
		int widgetsize = min(width(), height());
		
		m_BoxSize = ((double)widgetsize / fieldsize);
		/*min((double)width() / (m_Picture->width() + m_HeaderWidth), (double)height() / (m_Picture->height() + m_HeaderWidth));*/
		
		m_MarkerSize = m_BoxSize * 2.0/3.0;
		m_MarkerOffset = ((m_BoxSize - m_MarkerSize) / 2.0);
		
		m_HeaderWidth *= m_BoxSize;
		m_HeaderHeight = m_HeaderWidth;
		
		m_RasterWidth = m_BoxSize * m_Nonogram->width() + m_HeaderWidth;
		m_RasterHeight = m_BoxSize * m_Nonogram->height() + m_HeaderHeight;
		
		m_OffsetX = (width() - m_RasterWidth) / 2;
		m_OffsetY = (height() - m_RasterHeight) / 2;
		
		int clockHeight = /*m_Notifier->isVisible() ? m_HeaderHeight - m_Notifier->sizeHint().height()*/ /* * 3.0 / 4.0 */ /*:*/ m_HeaderHeight;
		
		if (m_Clock)
			m_Clock->setGeometry(m_OffsetX, m_OffsetY, m_HeaderWidth, clockHeight);
// 		if (m_Notifier && m_Notifier->isVisible())
// 			m_Notifier->setGeometry(m_OffsetX, m_OffsetY + clockHeight, m_HeaderWidth, m_Notifier->sizeHint().height());
		update();
	}
	
	void CCrossFieldWidget::mousePressEvent(QMouseEvent * event) {
		int pressedX = event->x() - m_OffsetX;
		int pressedY = event->y() - m_OffsetY;
		
		if (pressedX < m_HeaderWidth || pressedY < m_HeaderHeight || pressedX >= m_RasterWidth || pressedY >= m_RasterHeight)
			return;
		
		pressedX = (pressedX - m_HeaderWidth) / m_BoxSize;
		pressedY = (pressedY - m_HeaderHeight) / m_BoxSize;
		
		m_MouseLastX = pressedX; m_MouseLastY = pressedY;
		
		if (event->button() == Qt::RightButton)
			m_MouseMark = NonogramMarker::CROSSED;
		else
			m_MouseMark = NonogramMarker::MARKED;
		
		m_MouseDown = true;
		
		if (m_Nonogram->marker().pixel(pressedX, pressedY) == m_MouseMark)
			m_MouseMark = NonogramMarker::NONE;
		
		m_Nonogram->setMark(pressedX, pressedY, m_MouseMark);
	}
	
	void CCrossFieldWidget::mouseMoveEvent(QMouseEvent * event) {
		if (!m_MouseDown)
			return;
		
		int pressedX = event->x() - m_OffsetX;
		int pressedY = event->y() - m_OffsetY;
		
		if (pressedX < m_HeaderWidth || pressedY < m_HeaderHeight || pressedX >= m_RasterWidth || pressedY >= m_RasterHeight)
			return;
		
		pressedX = (pressedX - m_HeaderWidth) / m_BoxSize;
		pressedY = (pressedY - m_HeaderHeight) / m_BoxSize;
		
		if (pressedX == m_MouseLastX && pressedY == m_MouseLastY) return;
		m_MouseLastX = pressedX; m_MouseLastY = pressedY;
		
		m_Nonogram->setMark(pressedX, pressedY, m_MouseMark);
	}
	
	void CCrossFieldWidget::mouseReleaseEvent(QMouseEvent *) {
		m_MouseDown = false;
	}
}