/***************************************************************************
 *   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 <libqcross/cnonogram.h>
#include <QPainter>
#include <QMouseEvent>
#include <QLCDNumber>
#include <QDebug>
#include <QFrame>
#include <QLabel>
#include <QHBoxLayout>
#include <QStyle>
#include <QApplication>

namespace qcross {
	using namespace libqcross;

	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(CNonogram * picture, QWidget * parent) : QWidget(parent),
		m_Picture(picture),
		m_OverlayData(NULL),
		m_MouseMark(CMT_NONE),
		m_ErrorAware(false),
		m_NumbersMarkable(true),
		m_Time(0),
		m_Paused(true),
		m_Solved(false),
		m_TimerId(-1),
		m_MessageTimeoutId(-1),
		m_Clock(NULL),
		m_ErrorCount(0),
		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 = new QLCDNumber(8, this);
		m_Clock->setVisible(m_Picture);
		
		if (m_Picture) {
			initialize();
			m_RemainingPixels = m_Picture->blackPixels();
			updateTimeDisplay();
		}
		
		setEnabled(false);
	}
	
	CCrossFieldWidget::~CCrossFieldWidget() {
		cleanup();
		
		delete m_Clock;
	}
	
	void CCrossFieldWidget::setPicture(CNonogram * picture) {
		cleanup();
		m_Picture = picture;
		if (m_Picture) {
			m_LastErrorMark.setX(-1);
			m_LastErrorMark.setY(-1);
			m_ErrorCount = 0;
			m_Time = picture->timeout();
			m_ErrorAware = picture->timeout();
			m_Solved = false;
			
			updateTimeDisplay();
			emit timeChanged(m_Time);
			
			initialize();
			
			m_Messages.clear();
			nextMessage();
			
			updateMetrics();
			
			m_RemainingPixels = m_Picture->blackPixels();
		}
		m_Clock->setVisible(m_Picture);
	}
	//beim Laden eines neuen Spiels nach einem beendeten wird das neue nicht automatisch gestartet (Restart nötig)
	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::mark(int x, int y, qcross::MarkerType type) {
		if (type == CMT_NONE || x < 0 || x >= m_Picture->width() || y < 0 || y >= m_Picture->height())
			return;
		
		if (type == CMT_MARKED && checkNoError(x, y))
			m_OverlayData[x][y] = CMT_MARKED;
		else
			m_OverlayData[x][y] = type;
	}
	
	void CCrossFieldWidget::setTime(int value) {
		if (value < 0)
			value = 0;
		
		if (m_Time != value) {
			m_Time = value;
			
			if (m_ErrorAware && !m_Time) {
				killTimer(m_TimerId);
				m_Paused = true;
				emit timeUp();
			}
			
			updateTimeDisplay();
			
			emit timeChanged(m_Time);
		}
	}
	
	void CCrossFieldWidget::setErrorAware(bool value) {
		m_ErrorAware = value;
	}
	
	void CCrossFieldWidget::setNumbersMarkable(bool value) {
		m_NumbersMarkable = value;
	}
	
	void CCrossFieldWidget::start() {
		reset();
		resume();
	}
	
	void CCrossFieldWidget::pause() {
		if (m_Solved)
			return;
		
		killTimer(m_TimerId);
		m_Paused = true;
		setEnabled(false);
	}
	
	void CCrossFieldWidget::resume() {
		if (m_Solved)
			return;
		
		m_Paused = false;
		setEnabled(true);
		update();
		m_TimerId = startTimer(1000);
	}
	
	//protected
	void CCrossFieldWidget::nextMessage() {
		if (m_MessageTimeoutId != -1)
			killTimer(m_MessageTimeoutId);
		
		m_MessageTimeoutId = -1;
		
		if (m_Messages.isEmpty()) {
			m_Message.type = Invalid;
			update();
			return;
		}
		
		Message m_Next = m_Messages.dequeue();
		update();
		
//		switch (next.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(next.text);
		
//		m_Notifier->show();
//		updateMetrics();
		
		if (m_Message.timeout)
			m_MessageTimeoutId = startTimer(m_Message.timeout);
	}
	
	void CCrossFieldWidget::initialize() {
		m_OverlayData = new MarkerType *[m_Picture->width()];
		for (int i = 0; i < m_Picture->width(); i++) {
			m_OverlayData[i] = new MarkerType[m_Picture->height()];
			for (int j = 0; j < m_Picture->height(); j++)
				m_OverlayData[i][j] = CMT_UNMARKED;
		}
		
		int minimumW = max(m_Picture->maximumNumberCount()+1, 5);
		int minimumH = minimumW;
		
		minimumW += m_Picture->width();
		minimumH += m_Picture->height();
		
		int minimumBoxSize = max(fontMetrics().width(QString::number(m_Picture->height())), fontMetrics().width(QString::number(m_Picture->width())));
		minimumBoxSize = max(minimumBoxSize, fontInfo().pixelSize() * 1.5);
		
		minimumW *= minimumBoxSize;
		minimumH *= minimumBoxSize;
		
		setMinimumSize(minimumW, minimumH);
	}
	
	void CCrossFieldWidget::cleanup() {
		killTimer(m_TimerId);
		killTimer(m_MessageTimeoutId);
		
		if (m_OverlayData) {
			for (int i = 0; i < m_Picture->width(); i++)
				delete[] m_OverlayData[i];
			delete[] m_OverlayData;
			m_OverlayData = NULL;
		}
	}
	
	void CCrossFieldWidget::reset() {
		m_Messages.clear();
		nextMessage();
		
		for (int i = 0; i < m_Picture->width(); i++) {
			for (int j = 0; j < m_Picture->height(); j++)
				m_OverlayData[i][j] = CMT_UNMARKED;
		}
		
		m_Solved = false;
		m_ErrorCount = 0;
		m_LastErrorMark.setX(-1);
		m_LastErrorMark.setY(-1);
		m_RemainingPixels = m_Picture->blackPixels();
	}
	
	bool CCrossFieldWidget::checkNoError(int x, int y) {
		return (m_OverlayData[x][y] == CMT_MARKED) || m_Picture->pixel(x, y);
	}
	
	void CCrossFieldWidget::timerEvent(QTimerEvent * event) {
		if (event->timerId() == m_TimerId)
			setTime(m_Time + (m_ErrorAware ? -1 : +1));
		else if (event->timerId() == m_MessageTimeoutId)
			nextMessage();
	}
	
	void CCrossFieldWidget::updateTimeDisplay() {
		quint8 seconds = m_Time % 60;
		quint8 minutes = m_Time / 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::execMark(int x, int y) {
/*		if (m_OverlayData[x][y] == m_MouseMark)
			return;*/
		
		switch (m_MouseMark) {
		case CMT_MARKED:
			if (m_Picture->pixel(x, y)) {
				m_RemainingPixels--;
				m_OverlayData[x][y] = m_MouseMark;
			}
			else if (m_ErrorAware) {
				m_ErrorCount++;
				m_MouseMark = CMT_NONE;
				m_OverlayData[x][y] = CMT_CROSSED;
				m_LastErrorMark.setX(x);
				m_LastErrorMark.setY(y);
				emit markError();
			}
			else {
				m_ErrorCount++;
				m_OverlayData[x][y] = m_MouseMark;
			}
			break;
		case CMT_CROSSED:
		case CMT_UNMARKED:
			if (m_ErrorAware && x == m_LastErrorMark.x() && y == m_LastErrorMark.y()) {
				m_LastErrorMark.setX(-1);
				m_LastErrorMark.setY(-1);
			}
			
			if (m_OverlayData[x][y] == CMT_MARKED) {
				if (m_Picture->pixel(x, y))
					m_RemainingPixels++;
				else
					m_ErrorCount--;
			}
			
			m_OverlayData[x][y] = m_MouseMark;
			break;
		default:
			break;
		}
		
		if (!m_RemainingPixels && (m_ErrorAware || !m_ErrorCount)) {
			killTimer(m_TimerId);
			m_Paused = true;
			m_Solved = true;
			emit solved();
		}
	}
	
	void CCrossFieldWidget::paintEvent(QPaintEvent *) {
		QPainter painter(this);
		
		if (!m_Picture) {
/*			painter.drawText(originX, originY, m_BoxSize, m_BoxSize,
				Qt::AlignVCenter | Qt::AlignCenter, QString::number(m_Picture->rowNumbers(i)[m_Picture->rowNumbers(i).size() - j]));*/
			return;
		}
		
		int originX = m_OffsetX + m_HeaderWidth;
		int originY = m_OffsetY + m_HeaderHeight;
		
		int gridWidth  = m_RasterWidth - m_HeaderWidth;
		int gridHeight = m_RasterHeight - m_HeaderHeight;
		
		{
			const int delta = 5 * m_BoxSize;
			
			int offsetX = 0;
			int offsetY;
			int deltaX = delta;
			int deltaY;
			
			bool useBase = false;
			
			while (offsetX < gridWidth) {
				offsetY = 0;
				deltaY = delta;
				while (offsetY < gridHeight) {
					painter.fillRect(originX + offsetX, originY + offsetY, deltaX, deltaY,
						palette().color(useBase ? QPalette::Base : QPalette::AlternateBase));
					
					useBase = !useBase;
					
					offsetY += delta;
					
					if (gridWidth - offsetY < delta)
						deltaY = gridWidth - offsetY;
				}
				
				useBase = !useBase;
				
				offsetX += delta;
				
				if (gridWidth - offsetX < delta)
					deltaX = gridWidth - offsetX;
			}
		}
		
		painter.setBrush(palette().color(QPalette::Highlight));
		
		QFont font = painter.font();
		font.setPixelSize(m_MarkerSize * 0.9);
		
		{
			QPen pen;
			
			pen.setWidth(m_MarkerSize / 10);
			
			painter.setPen(pen);
		}
		
		QRectF markerRect(m_MarkerOffset, m_MarkerOffset, m_MarkerSize, m_MarkerSize);
		
		for (int i = 0; i < m_Picture->width(); i++) {
			originX = m_OffsetX + m_HeaderWidth + i * m_BoxSize;
			markerRect.moveLeft(originX + m_MarkerOffset);
			
			for (int j = 0; j < m_Picture->height(); j++) {
				originY = m_OffsetY + m_HeaderHeight + j * m_BoxSize;
				markerRect.moveTop(originY + m_MarkerOffset);
				
				switch (m_OverlayData[i][j]) {
				case CMT_MARKED:
					painter.fillRect(markerRect, painter.brush());
					break;
				case CMT_CROSSED:
					if (m_Solved)
						break;
					
					if (m_ErrorAware && m_ErrorCount && i == m_LastErrorMark.x() && j == m_LastErrorMark.y()) {
						painter.fillRect(markerRect, painter.brush());
					}
					
					painter.drawLine(markerRect.topLeft(), markerRect.bottomRight());
					painter.drawLine(markerRect.bottomLeft(), markerRect.topRight());
					break;
				default:
					break;
				}
			}
		}
		
		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);
		}
		
		if (m_Paused)
			painter.setPen(palette().color(QPalette::Shadow));
		
		painter.setFont(font);
		
		for (int i = 0; i < m_Picture->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_Paused) {
				painter.setPen(palette().color(QPalette::WindowText));
				for (int j = 1; j <= m_Picture->columnNumbers(i).size(); j++) {
					originY = m_OffsetY + m_HeaderHeight - j * m_BoxSize;
					
					painter.drawText(originX, originY, m_BoxSize, m_BoxSize,
						Qt::AlignVCenter | Qt::AlignCenter, QString::number(m_Picture->columnNumbers(i)[m_Picture->columnNumbers(i).size() - 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_Picture->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_Paused) {
				painter.setPen(palette().color(QPalette::WindowText));
				for (int j = 1; j <= m_Picture->rowNumbers(i).size(); j++) {
					originX = m_OffsetX + m_HeaderWidth - j * m_BoxSize;
					painter.drawText(originX, originY, m_BoxSize, m_BoxSize,
						Qt::AlignVCenter | Qt::AlignCenter, QString::number(m_Picture->rowNumbers(i)[m_Picture->rowNumbers(i).size() - j]));
				}
				painter.setPen(palette().color(QPalette::Shadow));
			}
			if (!(i % 5))
				painter.drawLine(m_OffsetX, originY, m_OffsetX + m_RasterWidth-1, originY);
		}
		
		if (m_Message.type != Invalid) {
			painter.drawText(m_HeaderWidth + m_OffsetX, m_HeaderHeight + m_OffsetY, m_Message.text);
		}
// 		painter.drawLine(m_OffsetX, m_OffsetY + m_RasterHeight, m_OffsetX + m_RasterWidth, m_OffsetY + m_RasterHeight);
	}
	
/*	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*/) {
		if (!m_Picture)
			return;
		
		updateMetrics();
	}
	
	void CCrossFieldWidget::updateMetrics() {
		m_HeaderWidth = max(m_Picture->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_Picture->width() + m_HeaderWidth), (m_Picture->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_Picture->width() + m_HeaderWidth;
		m_RasterHeight = m_BoxSize * m_Picture->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());
	}
	
	void CCrossFieldWidget::mousePressEvent(QMouseEvent * event) {
		if (m_Paused)
			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 (event->button() == Qt::RightButton)
			m_MouseMark = CMT_CROSSED;
		else
			m_MouseMark = CMT_MARKED;
		
		if (m_OverlayData[pressedX][pressedY] == m_MouseMark)
			m_MouseMark = CMT_UNMARKED;
		
		execMark(pressedX, pressedY);
		update();
	}
	
	void CCrossFieldWidget::mouseMoveEvent(QMouseEvent * event) {
		if (m_Paused)
			return;
		
		if (m_MouseMark == CMT_NONE)
			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 (m_OverlayData[pressedX][pressedY] != m_MouseMark) {
			execMark(pressedX, pressedY);
			update();
		}
	}
	
	void CCrossFieldWidget::mouseReleaseEvent(QMouseEvent *) {
		m_MouseMark = CMT_NONE;
	}
}