/***************************************************************************
 *   Copyright (C) 2005-2019 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE is free software; you can redistribute it and/or                 *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

// Standard C++ library includes
#include <cassert>

// 3rd party library includes

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "gui/fifechan/base/gui_font.h"
#include "util/base/exception.h"
#include "video/image.h"

#include "clicklabel.h"

namespace fcn {
	ClickLabel::ClickLabel()  {
		mGuiFont = static_cast<FIFE::GuiFont*>(getFont());
		setAlignment(Graphics::Left);
		setOpaque(true);
		mTextWrapping = false;
		setBorderSize(0);
		mHasMouse = false,
		mKeyPressed = false,
		mMousePressed = false;

		addMouseListener(this);
		addKeyListener(this);
		addFocusListener(this);
		addWidgetListener(this);
	}

	ClickLabel::ClickLabel(const std::string& caption) {
		mGuiFont = static_cast<FIFE::GuiFont*>(getFont());
		setCaption(caption);
		setAlignment(Graphics::Left);
		setOpaque(true);
		mTextWrapping = false;
		setBorderSize(0);
		mHasMouse = false,
		mKeyPressed = false,
		mMousePressed = false;

		adjustSize();
		addMouseListener(this);
		addKeyListener(this);
		addFocusListener(this);
		addWidgetListener(this);
	}

	ClickLabel::~ClickLabel() {
	}
	
	void ClickLabel::setCaption(const std::string& caption) {
		mCaption = caption;
		mGuiFont = static_cast<FIFE::GuiFont*>(getFont());
		wrapText();
	}

	const std::string& ClickLabel::getCaption() const {
		return mCaption;
	}

	void ClickLabel::setAlignment(Graphics::Alignment alignment) {
		mAlignment = alignment;
	}

	Graphics::Alignment ClickLabel::getAlignment() const {
		return mAlignment;
	}

	void ClickLabel::setOpaque(bool opaque) {
		mOpaque = opaque;
	}

	bool ClickLabel::isOpaque() const {
		return mOpaque;
	}

	void ClickLabel::setTextWrapping(bool textWrapping) {
		bool wrappingEnabled = !mTextWrapping && textWrapping;
		mTextWrapping = textWrapping;
		if (wrappingEnabled) {
			wrapText();
		}
	}

	bool ClickLabel::isTextWrapping() const {
		return mTextWrapping;
	}

	void ClickLabel::wrapText() {
		if (isTextWrapping() && mGuiFont) {
			int32_t w = getWidth() - 2 * getBorderSize() - getPaddingLeft() - getPaddingRight();
			mWrappedText = mGuiFont->splitTextToWidth(mCaption, w);
		}
	}

	void ClickLabel::setDimension(const Rectangle& dimension) {
		int32_t w = getWidth();
		Widget::setDimension(dimension);
		if (getWidth() != w && isTextWrapping()) {
			wrapText();
		}
	}

	void ClickLabel::resizeToContent(bool recursiv) {
		adjustSize();
	}

	void  ClickLabel::adjustSize() {
		if (mGuiFont) {
			int32_t w = getWidth();
			int32_t h = 0;
			if (isTextWrapping()) {
				if (getParent()) {
					w = getParent()->getChildrenArea().width;
				}
				int32_t textW = w - 2 * getBorderSize() - getPaddingLeft() - getPaddingRight();
				int32_t maxW = isFixedSize() ? getFixedSize().getWidth() : getMaxSize().getWidth();
				if (textW < 1) {
					w = maxW;
					textW = w - 2 * getBorderSize() - getPaddingLeft() - getPaddingRight();
				} else if (w > maxW) {
					w = std::min(w, maxW);
					textW = w - 2 * getBorderSize() - getPaddingLeft() - getPaddingRight();
				}
				mWrappedText = mGuiFont->splitTextToWidth(mCaption, textW);
			} else {
				FIFE::Image* image = mGuiFont->getAsImageMultiline(mCaption);
				w = image->getWidth() + 2 * getBorderSize() + getPaddingLeft() + getPaddingRight();
			}
			const std::string& text = isTextWrapping() ? mWrappedText : mCaption;
			FIFE::Image* image = mGuiFont->getAsImageMultiline(text);
			h = 2 * getBorderSize() + getPaddingTop() + getPaddingBottom() + image->getHeight();
			setSize(w, h);
		}
	}

	void ClickLabel::draw(Graphics* graphics) {
		bool active = isFocused();
		Rectangle offsetRec(getBorderSize(), getBorderSize(), 2 * getBorderSize(), 2 * getBorderSize());

		if (isOpaque()) {
			Color faceColor = getBackgroundColor();
			if (active && ((getSelectionMode() & Widget::Selection_Background) == Widget::Selection_Background)) {
				faceColor = getSelectionColor();
			}
			graphics->setColor(faceColor);
			graphics->fillRectangle(offsetRec.x, offsetRec.y, getWidth() - offsetRec.width, getHeight() - offsetRec.height);
		}

		if (getBorderSize() > 0) {
			if (active && (getSelectionMode() & Widget::Selection_Border) == Widget::Selection_Border) {
				drawSelectionFrame(graphics);
			} else {
				drawBorder(graphics);
			}
		}

		if (mGuiFont) {
			graphics->setColor(getForegroundColor());
			const std::string& text = isTextWrapping() ? mWrappedText : mCaption;
			FIFE::Image* image = mGuiFont->getAsImageMultiline(text);

			int32_t textX = 0;
			int32_t textY = offsetRec.y + getPaddingTop() + (getHeight() - offsetRec.height - getPaddingTop() - getPaddingBottom() - image->getHeight()) / 2;

			switch (getAlignment()) {
			  case Graphics::Left:
				  textX = offsetRec.x + getPaddingLeft();
				  break;
			  case Graphics::Center:
				  textX = offsetRec.x + getPaddingLeft() + (getWidth() - offsetRec.width - getPaddingLeft() - getPaddingRight() - image->getWidth()) / 2;
				  break;
			  case Graphics::Right:
				  textX = getWidth() - offsetRec.x - getPaddingRight() - image->getWidth();
				  break;
			  default:
				  throw FCN_EXCEPTION("Unknown alignment.");
			}

			mGuiFont->drawMultiLineString(graphics, text, textX, textY);
		}
	}

	void ClickLabel::fontChanged() {
		mGuiFont = static_cast<FIFE::GuiFont*>(getFont());
		wrapText();
		adjustSize();
	}

	void ClickLabel::mousePressed(MouseEvent& mouseEvent) {
		if (mouseEvent.getButton() == MouseEvent::Left) {
			mMousePressed = true;
			mouseEvent.consume();
		}
	}

	void ClickLabel::mouseExited(MouseEvent& mouseEvent) {
		mHasMouse = false;
	}

	void ClickLabel::mouseEntered(MouseEvent& mouseEvent) {
		mHasMouse = true;
	}

	void ClickLabel::mouseReleased(MouseEvent& mouseEvent) {
		if (mouseEvent.getButton() == MouseEvent::Left && mMousePressed && mHasMouse) {
			mMousePressed = false;
			distributeActionEvent();
			mouseEvent.consume();
		} else if (mouseEvent.getButton() == MouseEvent::Left) {
			mMousePressed = false;
			mouseEvent.consume();
		}
	}

	void ClickLabel::mouseDragged(MouseEvent& mouseEvent) {
		mouseEvent.consume();
	}

	void ClickLabel::keyPressed(KeyEvent& keyEvent) {
		Key key = keyEvent.getKey();

		if (key.getValue() == Key::Enter || key.getValue() == Key::Space) {
			mKeyPressed = true;
			keyEvent.consume();
		}
	}

	void ClickLabel::keyReleased(KeyEvent& keyEvent) {
		Key key = keyEvent.getKey();

		if ((key.getValue() == Key::Enter || key.getValue() == Key::Space) && mKeyPressed) {
			mKeyPressed = false;
			distributeActionEvent();
			keyEvent.consume();
		}
	}

	void ClickLabel::focusLost(const Event& event) {
		mMousePressed = false;
		mKeyPressed = false;
		mHasMouse = false;
	}

	void ClickLabel::ancestorHidden(const Event& event) {
		mMousePressed = false;
		mKeyPressed = false;
		mHasMouse = false;
	}
}