/*
 *  The ManaPlus Client
 *  Copyright (C) 2004-2009  The Mana World Development Team
 *  Copyright (C) 2009-2010  The Mana Developers
 *  Copyright (C) 2011-2014  The ManaPlus Developers
 *
 *  This file is part of The ManaPlus Client.
 *
 *  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
 *  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, see <http://www.gnu.org/licenses/>.
 */

#include "gui/viewport.h"

#include "actormanager.h"
#include "configuration.h"
#include "game.h"
#include "maplayer.h"
#include "sdlshared.h"
#include "textmanager.h"

#include "being/localplayer.h"
#include "being/playerinfo.h"

#include "input/inputmanager.h"

#include "gui/gui.h"
#include "gui/font.h"

#include "gui/popups/beingpopup.h"
#include "gui/popups/popupmenu.h"
#include "gui/popups/textpopup.h"

#include "gui/windows/ministatuswindow.h"

#include "utils/delete2.h"

#include "debug.h"

extern volatile int tick_time;
extern MiniStatusWindow *miniStatusWindow;

Viewport::Viewport() :
    WindowContainer(nullptr),
    MouseListener(),
    mMap(nullptr),
    mPopupMenu(new PopupMenu),
    mHoverBeing(nullptr),
    mHoverItem(nullptr),
    mHoverSign(nullptr),
    mBeingPopup(new BeingPopup),
    mTextPopup(new TextPopup),
    mScrollRadius(config.getIntValue("ScrollRadius")),
    mScrollLaziness(config.getIntValue("ScrollLaziness")),
    mScrollCenterOffsetX(config.getIntValue("ScrollCenterOffsetX")),
    mScrollCenterOffsetY(config.getIntValue("ScrollCenterOffsetY")),
    mMouseX(0),
    mMouseY(0),
    mMousePressX(0),
    mMousePressY(0),
    mPixelViewX(0),
    mPixelViewY(0),
    mShowDebugPath(Map::MAP_NORMAL),
    mCameraMode(0),
    mLocalWalkTime(-1),
    mCameraRelativeX(0),
    mCameraRelativeY(0),
    mShowBeingPopup(config.getBoolValue("showBeingPopup")),
    mSelfMouseHeal(config.getBoolValue("selfMouseHeal")),
    mEnableLazyScrolling(config.getBoolValue("enableLazyScrolling")),
    mMouseDirectionMove(config.getBoolValue("mouseDirectionMove")),
    mLongMouseClick(config.getBoolValue("longmouseclick")),
    mMouseClicked(false),
    mPlayerFollowMouse(false)
{
    mBeingPopup->postInit();
    mPopupMenu->postInit();
    mTextPopup->postInit();

    setOpaque(false);
    addMouseListener(this);

    config.addListener("ScrollLaziness", this);
    config.addListener("ScrollRadius", this);
    config.addListener("showBeingPopup", this);
    config.addListener("selfMouseHeal", this);
    config.addListener("enableLazyScrolling", this);
    config.addListener("mouseDirectionMove", this);
    config.addListener("longmouseclick", this);

    setFocusable(true);
}

Viewport::~Viewport()
{
    config.removeListeners(this);
    CHECKLISTENERS
    delete2(mPopupMenu);
    delete2(mBeingPopup);
    delete2(mTextPopup);
}

void Viewport::setMap(Map *const map)
{
    if (mMap && map)
        map->setDebugFlags(mMap->getDebugFlags());
    mMap = map;
}

void Viewport::draw(Graphics *graphics)
{
    BLOCK_START("Viewport::draw 1")
    static int lastTick = tick_time;

    if (!mMap || !player_node)
    {
        graphics->setColor(Color(64, 64, 64));
        graphics->fillRectangle(
                Rect(0, 0, getWidth(), getHeight()));
        BLOCK_END("Viewport::draw 1")
        return;
    }

    // Avoid freaking out when tick_time overflows
    if (tick_time < lastTick)
        lastTick = tick_time;

    // Calculate viewpoint
    const int midTileX = (graphics->mWidth + mScrollCenterOffsetX) / 2;
    const int midTileY = (graphics->mHeight + mScrollCenterOffsetY) / 2;

    const Vector &playerPos = player_node->getPosition();
    const int player_x = static_cast<int>(playerPos.x)
                         - midTileX + mCameraRelativeX;
    const int player_y = static_cast<int>(playerPos.y)
                         - midTileY + mCameraRelativeY;

    if (mScrollLaziness < 1)
        mScrollLaziness = 1;  // Avoids division by zero

    if (mEnableLazyScrolling)
    {
        int cnt = 0;

        // Apply lazy scrolling
        while (lastTick < tick_time && cnt < mapTileSize)
        {
            if (player_x > mPixelViewX + mScrollRadius)
            {
                mPixelViewX += static_cast<float>(player_x
                    - mPixelViewX - mScrollRadius) /
                    static_cast<float>(mScrollLaziness);
            }
            if (player_x < mPixelViewX - mScrollRadius)
            {
                mPixelViewX += static_cast<float>(player_x
                    - mPixelViewX + mScrollRadius) /
                    static_cast<float>(mScrollLaziness);
            }
            if (player_y > mPixelViewY + mScrollRadius)
            {
                mPixelViewY += static_cast<float>(player_y
                - mPixelViewY - mScrollRadius) /
                static_cast<float>(mScrollLaziness);
            }
            if (player_y < mPixelViewY - mScrollRadius)
            {
                mPixelViewY += static_cast<float>(player_y
                - mPixelViewY + mScrollRadius) /
                static_cast<float>(mScrollLaziness);
            }
            lastTick ++;
            cnt ++;
        }

        // Auto center when player is off screen
        if (cnt > 30 || player_x - mPixelViewX
            > graphics->mWidth / 2 || mPixelViewX
            - player_x > graphics->mWidth / 2 || mPixelViewY
            - player_y > graphics->getHeight() / 2 ||  player_y
            - mPixelViewY > graphics->getHeight() / 2)
        {
            if (player_x <= 0 || player_y <= 0)
            {
                logger->log("incorrect player position: %d, %d, %d, %d",
                    player_x, player_y, mPixelViewX, mPixelViewY);
                if (player_node)
                {
                    logger->log("tile position: %d, %d",
                        player_node->getTileX(), player_node->getTileY());
                }
            }
            mPixelViewX = player_x;
            mPixelViewY = player_y;
        }
    }
    else
    {
        mPixelViewX = player_x;
        mPixelViewY = player_y;
    }

    // Don't move camera so that the end of the map is on screen
    const int viewXmax =
        mMap->getWidth() * mMap->getTileWidth() - graphics->mWidth;
    const int viewYmax =
        mMap->getHeight() * mMap->getTileHeight() - graphics->mHeight;

    if (mPixelViewX < 0)
        mPixelViewX = 0;
    if (mPixelViewY < 0)
        mPixelViewY = 0;
    if (mPixelViewX > viewXmax)
        mPixelViewX = viewXmax;
    if (mPixelViewY > viewYmax)
        mPixelViewY = viewYmax;

    // Draw tiles and sprites
    mMap->draw(graphics, mPixelViewX, mPixelViewY);

    if (mShowDebugPath)
    {
        mMap->drawCollision(graphics, mPixelViewX,
            mPixelViewY, mShowDebugPath);
        if (mShowDebugPath == Map::MAP_DEBUG)
            drawDebugPath(graphics);
    }

    if (player_node->getCheckNameSetting())
    {
        player_node->setCheckNameSetting(false);
        player_node->setName(player_node->getName());
    }

    // Draw text
    if (textManager)
        textManager->draw(graphics, mPixelViewX, mPixelViewY);

    // Draw player names, speech, and emotion sprite as needed
    const ActorSprites &actors = actorManager->getAll();
    FOR_EACH (ActorSpritesIterator, it, actors)
    {
        if ((*it)->getType() == ActorSprite::FLOOR_ITEM)
            continue;
        Being *const b = static_cast<Being*>(*it);
        b->drawSpeech(mPixelViewX, mPixelViewY);
        b->drawEmotion(graphics, mPixelViewX, mPixelViewY);
    }

    if (miniStatusWindow)
        miniStatusWindow->drawIcons(graphics);

    // Draw contained widgets
    WindowContainer::draw(graphics);
    BLOCK_END("Viewport::draw 1")
}

void Viewport::logic()
{
    BLOCK_START("Viewport::logic")
    // Make the player follow the mouse position
    // if the mouse is dragged elsewhere than in a window.
    Gui::getMouseState(&mMouseX, &mMouseY);
    BLOCK_END("Viewport::logic")
}

void Viewport::followMouse()
{
    if (!gui)
        return;
    const uint8_t button = Gui::getMouseState(&mMouseX, &mMouseY);
    // If the left button is dragged
    if (mPlayerFollowMouse && (button & SDL_BUTTON(1)))
    {
        // We create a mouse event and send it to mouseDragged.
        MouseEvent event(nullptr,
            MouseEvent::DRAGGED,
            MouseEvent::LEFT,
            mMouseX,
            mMouseY,
            0);

        walkByMouse(event);
    }
}

void Viewport::drawDebugPath(Graphics *const graphics)
{
    if (!player_node || !userPalette || !actorManager || !mMap || !gui)
        return;

    Gui::getMouseState(&mMouseX, &mMouseY);

    static Path debugPath;
    static Vector lastMouseDestination = Vector(0.0F, 0.0F);
    const int mousePosX = mMouseX + mPixelViewX;
    const int mousePosY = mMouseY + mPixelViewY;
    Vector mouseDestination(mousePosX, mousePosY);

    if (mouseDestination.x != lastMouseDestination.x
        || mouseDestination.y != lastMouseDestination.y)
    {
        const Vector &playerPos = player_node->getPosition();

        debugPath = mMap->findPath(
            static_cast<int>(playerPos.x - mapTileSize / 2) / mapTileSize,
            static_cast<int>(playerPos.y - mapTileSize) / mapTileSize,
            mousePosX / mapTileSize, mousePosY / mapTileSize,
            player_node->getWalkMask(),
            500);
        lastMouseDestination = mouseDestination;
    }
    drawPath(graphics, debugPath, userPalette->getColorWithAlpha(
        UserPalette::ROAD_POINT));

    const ActorSprites &actors = actorManager->getAll();
    FOR_EACH (ActorSpritesConstIterator, it, actors)
    {
        const Being *const being = dynamic_cast<const Being*>(*it);
        if (being && being != player_node)
        {
            const Path &beingPath = being->getPath();
            drawPath(graphics, beingPath, userPalette->getColorWithAlpha(
                UserPalette::ROAD_POINT));
        }
    }
}

void Viewport::drawPath(Graphics *const graphics,
                        const Path &path,
                        const Color &color) const
{
    graphics->setColor(color);
    Font *const font = getFont();

    int cnt = 1;
    FOR_EACH (Path::const_iterator, i, path)
    {
        const int squareX = i->x * mapTileSize - mPixelViewX + 12;
        const int squareY = i->y * mapTileSize - mPixelViewY + 12;

        graphics->fillRectangle(Rect(squareX, squareY, 8, 8));
        if (mMap)
        {
            const std::string str = toString(cnt);
            font->drawString(graphics, str, squareX + 4
                - font->getWidth(str) / 2, squareY + 12);
        }
        cnt ++;
    }
}

bool Viewport::openContextMenu(const MouseEvent &event)
{
    mPlayerFollowMouse = false;
    const int eventX = event.getX();
    const int eventY = event.getY();
    if (mHoverBeing)
    {
        validateSpeed();
        if (actorManager)
        {
            std::vector<ActorSprite*> beings;
            const int x = mMouseX + mPixelViewX;
            const int y = mMouseY + mPixelViewY;
            actorManager->findBeingsByPixel(beings, x, y, true);
            if (beings.size() > 1)
                mPopupMenu->showPopup(eventX, eventY, beings);
            else
                mPopupMenu->showPopup(eventX, eventY, mHoverBeing);
            return true;
        }
    }
    else if (mHoverItem)
    {
        validateSpeed();
        mPopupMenu->showPopup(eventX, eventY, mHoverItem);
        return true;
    }
    else if (mHoverSign)
    {
        validateSpeed();
        mPopupMenu->showPopup(eventX, eventY, mHoverSign);
        return true;
    }
    else if (mCameraMode)
    {
        mPopupMenu->showMapPopup(eventX, eventY,
            (mMouseX + mPixelViewX) / mMap->getTileWidth(),
            (mMouseY + mPixelViewY) / mMap->getTileHeight());
        return true;
    }
    return false;
}

bool Viewport::leftMouseAction()
{
    // Interact with some being
    if (mHoverBeing)
    {
        if (!mHoverBeing->isAlive())
            return true;

        if (mHoverBeing->canTalk())
        {
            validateSpeed();
            mHoverBeing->talkTo();
            return true;
        }
        else
        {
            const ActorSprite::Type type = mHoverBeing->getType();
            if (type == ActorSprite::PLAYER)
            {
                validateSpeed();
                if (actorManager)
                {
                    if (player_node != mHoverBeing || mSelfMouseHeal)
                        actorManager->heal(mHoverBeing);
                    if (player_node == mHoverBeing && mHoverItem)
                        player_node->pickUp(mHoverItem);
                    return true;
                }
            }
            else if (type == ActorSprite::MONSTER || type == ActorSprite::NPC)
            {
                if (player_node->withinAttackRange(mHoverBeing) ||
                    inputManager.isActionActive(static_cast<int>(
                    Input::KEY_ATTACK)))
                {
                    validateSpeed();
                    if (!mStatsReUpdated && player_node != mHoverBeing)
                    {
                        player_node->attack(mHoverBeing,
                            !inputManager.isActionActive(
                            static_cast<int>(Input::KEY_STOP_ATTACK)));
                        return true;
                    }
                }
                else if (!inputManager.isActionActive(static_cast<int>(
                         Input::KEY_ATTACK)))
                {
                    validateSpeed();
                    if (!mStatsReUpdated && player_node != mHoverBeing)
                    {
                        player_node->setGotoTarget(mHoverBeing);
                        return true;
                    }
                }
            }
        }
    }
    // Picks up a item if we clicked on one
    if (mHoverItem)
    {
        validateSpeed();
        player_node->pickUp(mHoverItem);
    }
    // Just walk around
    else if (!inputManager.isActionActive(static_cast<int>(
             Input::KEY_ATTACK)))
    {
        validateSpeed();
        player_node->stopAttack();
        player_node->cancelFollow();
        mPlayerFollowMouse = true;

        // Make the player go to the mouse position
        followMouse();
    }
    return false;
}

void Viewport::mousePressed(MouseEvent &event)
{
    if (event.getSource() != this || event.isConsumed())
        return;

    mMouseClicked = true;
    // Check if we are alive and kickin'
    if (!mMap || !player_node)
        return;

    // Check if we are busy
    // if commented, allow context menu if npc dialog open
    if (PlayerInfo::isTalking())
        return;

    mMousePressX = event.getX();
    mMousePressY = event.getY();
    const unsigned int eventButton = event.getButton();
    const int pixelX = mMousePressX + mPixelViewX;
    const int pixelY = mMousePressY + mPixelViewY;

    // Right click might open a popup
    if (eventButton == MouseEvent::RIGHT)
    {
        if (openContextMenu(event))
            return;
    }

    // If a popup is active, just remove it
    if (mPopupMenu->isPopupVisible())
    {
        mPlayerFollowMouse = false;
        mPopupMenu->setVisible(false);
        return;
    }

    // Left click can cause different actions
    if (!mLongMouseClick && eventButton == MouseEvent::LEFT)
    {
        if (leftMouseAction())
        {
            mPlayerFollowMouse = false;
            return;
        }
    }
    else if (eventButton == MouseEvent::MIDDLE)
    {
        mPlayerFollowMouse = false;
        validateSpeed();
        // Find the being nearest to the clicked position
        if (actorManager)
        {
            Being *const target = actorManager->findNearestLivingBeing(
                pixelX, pixelY, 20, ActorSprite::MONSTER);

            if (target)
                player_node->setTarget(target);
        }
    }
}

void Viewport::walkByMouse(const MouseEvent &event)
{
    if (!mMap || !player_node)
        return;
    if (mPlayerFollowMouse
        && !inputManager.isActionActive(Input::KEY_STOP_ATTACK)
        && !inputManager.isActionActive(Input::KEY_UNTARGET))
    {
        if (!mMouseDirectionMove)
            mPlayerFollowMouse = false;
        if (mLocalWalkTime != player_node->getActionTime())
        {
            mLocalWalkTime = cur_time;
            player_node->unSetPickUpTarget();
            int playerX = player_node->getTileX();
            int playerY = player_node->getTileY();
            if (mMouseDirectionMove)
            {
                const int width = mainGraphics->mWidth / 2;
                const int height = mainGraphics->mHeight / 2;
                const float wh = static_cast<float>(width)
                    / static_cast<float>(height);
                int x = event.getX() - width;
                int y = event.getY() - height;
                if (!x && !y)
                    return;
                const int x2 = abs(x);
                const int y2 = abs(y);
                const float diff = 2;
                int dx = 0;
                int dy = 0;
                if (x2 > y2)
                {
                    if (y2 && x2 / y2 / wh > diff)
                        y = 0;
                }
                else
                {
                    if (x2 && y2 * wh / x2 > diff)
                        x = 0;
                }
                if (x > 0)
                    dx = 1;
                else if (x < 0)
                    dx = -1;
                if (y > 0)
                    dy = 1;
                else if (y < 0)
                    dy = -1;

                if (mMap->getWalk(playerX + dx, playerY + dy))
                {
                    player_node->navigateTo(playerX + dx, playerY + dy);
                }
                else
                {
                    if (dx && dy)
                    {
                        // try avoid diagonal collision
                        if (x2 > y2)
                        {
                            if (mMap->getWalk(playerX + dx, playerY))
                                dy = 0;
                            else
                                dx = 0;
                        }
                        else
                        {
                            if (mMap->getWalk(playerX, playerY + dy))
                                dx = 0;
                            else
                                dy = 0;
                        }
                    }
                    else
                    {
                        // try avoid vertical or horisontal collision
                        if (!dx)
                        {
                            if (mMap->getWalk(playerX + 1, playerY + dy))
                                dx = 1;
                            if (mMap->getWalk(playerX - 1, playerY + dy))
                                dx = -1;
                        }
                        if (!dy)
                        {
                            if (mMap->getWalk(playerX + dx, playerY + 1))
                                dy = 1;
                            if (mMap->getWalk(playerX + dx, playerY - 1))
                                dy = -1;
                        }
                    }
                    player_node->navigateTo(playerX + dx, playerY + dy);
                }
            }
            else
            {
                const int destX = (event.getX() + mPixelViewX)
                    / static_cast<float>(mMap->getTileWidth());
                const int destY = (event.getY() + mPixelViewY)
                    / static_cast<float>(mMap->getTileHeight());
                if (playerX != destX || playerY != destY)
                {
                    if (!player_node->navigateTo(destX, destY))
                    {
                        if (playerX > destX)
                            playerX --;
                        else if (playerX < destX)
                            playerX ++;
                        if (playerY > destY)
                            playerY --;
                        else if (playerY < destY)
                            playerY ++;
                        if (mMap->getWalk(playerX, playerY, 0))
                            player_node->navigateTo(playerX, playerY);
                    }
                }
            }
        }
    }
}

void Viewport::mouseDragged(MouseEvent &event)
{
    if (event.getSource() != this || event.isConsumed())
    {
        mPlayerFollowMouse = false;
        return;
    }
    if (mMouseClicked)
    {
        if (abs(event.getX() - mMousePressX) > 32
            || abs(event.getY() - mMousePressY) > 32)
        {
            mPlayerFollowMouse = true;
        }
    }

    walkByMouse(event);
}

void Viewport::mouseReleased(MouseEvent &event)
{
    mPlayerFollowMouse = false;
    mLocalWalkTime = -1;
    if (mLongMouseClick && mMouseClicked)
    {
        mMouseClicked = false;
        if (event.getSource() != this || event.isConsumed())
            return;
        const unsigned int eventButton = event.getButton();
        if (eventButton == MouseEvent::LEFT)
        {
            // long button press
            if (gui && gui->isLongPress())
            {
                if (openContextMenu(event))
                {
                    gui->resetClickCount();
                    return;
                }
            }
            else
            {
                if (leftMouseAction())
                    return;
            }
            walkByMouse(event);
        }
    }
}

void Viewport::showPopup(Window *const parent,
                         const int x, const int y,
                         Item *const item,
                         const bool isInventory)
{
    mPopupMenu->showPopup(parent, x, y, item, isInventory);
}

void Viewport::showPopup(MapItem *const item)
{
    mPopupMenu->showPopup(mMouseX, mMouseY, item);
}

void Viewport::showPopup(Window *const parent,
                         Item *const item,
                         const bool isInventory)
{
    mPopupMenu->showPopup(parent, mMouseX, mMouseY, item, isInventory);
}

void Viewport::showItemPopup(Item *const item)
{
    mPopupMenu->showItemPopup(mMouseX, mMouseY, item);
}

void Viewport::showItemPopup(const int itemId,
                             const unsigned char color)
{
    mPopupMenu->showItemPopup(mMouseX, mMouseY, itemId, color);
}

void Viewport::showDropPopup(Item *const item)
{
    mPopupMenu->showDropPopup(mMouseX, mMouseY, item);
}

void Viewport::showOutfitsPopup(const int x, const int y)
{
    mPopupMenu->showOutfitsPopup(x, y);
}

void Viewport::showOutfitsPopup()
{
    mPopupMenu->showOutfitsPopup(mMouseX, mMouseY);
}

void Viewport::showSpellPopup(TextCommand *const cmd)
{
    mPopupMenu->showSpellPopup(mMouseX, mMouseY, cmd);
}

void Viewport::showChatPopup(const int x, const int y,
                             ChatTab *const tab)
{
    mPopupMenu->showChatPopup(x, y, tab);
}

void Viewport::showChatPopup(ChatTab *const tab)
{
    mPopupMenu->showChatPopup(mMouseX, mMouseY, tab);
}

void Viewport::showPopup(const int x, const int y,
                         const Being *const being)
{
    mPopupMenu->showPopup(x, y, being);
}

void Viewport::showPopup(const Being *const being)
{
    mPopupMenu->showPopup(mMouseX, mMouseY, being);
}

void Viewport::showPlayerPopup(const std::string &nick)
{
    mPopupMenu->showPlayerPopup(mMouseX, mMouseY, nick);
}

void Viewport::showPopup(const int x, const int y,
                         Button *const button)
{
    mPopupMenu->showPopup(x, y, button);
}

void Viewport::showPopup(const int x, const int y,
                         const ProgressBar *const bar)
{
    mPopupMenu->showPopup(x, y, bar);
}

void Viewport::showAttackMonsterPopup(const std::string &name,
                                      const int type)
{
    mPopupMenu->showAttackMonsterPopup(mMouseX, mMouseY, name, type);
}

void Viewport::showPickupItemPopup(const std::string &name)
{
    mPopupMenu->showPickupItemPopup(mMouseX, mMouseY, name);
}

void Viewport::showUndressPopup(const int x, const int y,
                                const Being *const being,
                                Item *const item)
{
    mPopupMenu->showUndressPopup(x, y, being, item);
}

void Viewport::showMapPopup(const int x, const int y)
{
    mPopupMenu->showMapPopup(mMouseX, mMouseY, x, y);
}

void Viewport::showTextFieldPopup(TextField *const input)
{
    mPopupMenu->showTextFieldPopup(mMouseX, mMouseY, input);
}

void Viewport::showLinkPopup(const std::string &link)
{
    mPopupMenu->showLinkPopup(mMouseX, mMouseY, link);
}

void Viewport::showWindowsPopup()
{
    mPopupMenu->showWindowsPopup(mMouseX, mMouseY);
}

void Viewport::showNpcDialogPopup(const int npcId)
{
    mPopupMenu->showNpcDialogPopup(npcId, mMouseX, mMouseY);
}

void Viewport::showWindowPopup(Window *const window)
{
    mPopupMenu->showWindowPopup(window, mMouseX, mMouseY);
}

void Viewport::closePopupMenu()
{
    if (mPopupMenu)
        mPopupMenu->handleLink("cancel", nullptr);
}

void Viewport::optionChanged(const std::string &name)
{
    if (name == "ScrollLaziness")
        mScrollLaziness = config.getIntValue("ScrollLaziness");
    else if (name == "ScrollRadius")
        mScrollRadius = config.getIntValue("ScrollRadius");
    else if (name == "showBeingPopup")
        mShowBeingPopup = config.getBoolValue("showBeingPopup");
    else if (name == "selfMouseHeal")
        mSelfMouseHeal = config.getBoolValue("selfMouseHeal");
    else if (name == "enableLazyScrolling")
        mEnableLazyScrolling = config.getBoolValue("enableLazyScrolling");
    else if (name == "mouseDirectionMove")
        mMouseDirectionMove = config.getBoolValue("mouseDirectionMove");
    else if (name == "longmouseclick")
        mLongMouseClick = config.getBoolValue("longmouseclick");
}

void Viewport::mouseMoved(MouseEvent &event A_UNUSED)
{
    // Check if we are on the map
    if (!mMap || !player_node || !actorManager)
        return;

    if (mMouseDirectionMove)
        mPlayerFollowMouse = false;

    const int x = mMouseX + mPixelViewX;
    const int y = mMouseY + mPixelViewY;

    ActorSprite::Type type = ActorSprite::UNKNOWN;
    mHoverBeing = actorManager->findBeingByPixel(x, y, true);
    if (mHoverBeing)
        type = mHoverBeing->getType();
    if (mHoverBeing
        && (type == Being::PLAYER
        || type == Being::NPC
        || type == Being::PET))
    {
        mTextPopup->setVisible(false);
        if (mShowBeingPopup)
            mBeingPopup->show(mMouseX, mMouseY, mHoverBeing);
    }
    else
    {
        mBeingPopup->setVisible(false);
    }

    mHoverItem = actorManager->findItem(x / mMap->getTileWidth(),
        y / mMap->getTileHeight());

    if (!mHoverBeing && !mHoverItem)
    {
        const SpecialLayer *const specialLayer = mMap->getSpecialLayer();
        if (specialLayer)
        {
            const int mouseTileX = (mMouseX + mPixelViewX)
                / mMap->getTileWidth();
            const int mouseTileY = (mMouseY + mPixelViewY)
                / mMap->getTileHeight();

            mHoverSign = specialLayer->getTile(mouseTileX, mouseTileY);
            if (mHoverSign && mHoverSign->getType() != MapItem::EMPTY)
            {
                if (!mHoverSign->getComment().empty())
                {
                    mBeingPopup->setVisible(false);
                    mTextPopup->show(mMouseX, mMouseY,
                        mHoverSign->getComment());
                }
                else
                {
                    if (mTextPopup->isPopupVisible())
                        mTextPopup->setVisible(false);
                }
                gui->setCursorType(Cursor::CURSOR_UP);
                return;
            }
        }
    }
    if (mTextPopup->isPopupVisible())
        mTextPopup->setVisible(false);

    if (mHoverBeing)
    {
        switch (type)
        {
            case ActorSprite::NPC:
                gui->setCursorType(mHoverBeing->getHoverCursor());
                break;

            case ActorSprite::MONSTER:
                gui->setCursorType(mHoverBeing->getHoverCursor());
                break;

            case ActorSprite::PORTAL:
                gui->setCursorType(mHoverBeing->getHoverCursor());
                break;

            case ActorSprite::AVATAR:
            case ActorSprite::FLOOR_ITEM:
            case ActorSprite::UNKNOWN:
            case ActorSprite::PLAYER:
            case ActorSprite::PET:
            default:
                gui->setCursorType(Cursor::CURSOR_POINTER);
                break;
        }
    }
    // Item mouseover
    else if (mHoverItem)
    {
        gui->setCursorType(mHoverItem->getHoverCursor());
    }
    else
    {
        gui->setCursorType(Cursor::CURSOR_POINTER);
    }
}

void Viewport::toggleDebugPath()
{
    mShowDebugPath++;
    if (mShowDebugPath > Map::MAP_BLACKWHITE)
        mShowDebugPath = Map::MAP_NORMAL;
    if (mMap)
        mMap->setDebugFlags(mShowDebugPath);
}

void Viewport::toggleCameraMode()
{
    mCameraMode++;
    if (mCameraMode > 1)
        mCameraMode = 0;
    if (!mCameraMode)
    {
        mCameraRelativeX = 0;
        mCameraRelativeY = 0;
    }
    if (miniStatusWindow)
        miniStatusWindow->updateStatus();
}

void Viewport::hideBeingPopup()
{
    if (mBeingPopup)
        mBeingPopup->setVisible(false);
    if (mTextPopup)
        mTextPopup->setVisible(false);
}

void Viewport::clearHover(const ActorSprite *const actor)
{
    if (mHoverBeing == actor)
        mHoverBeing = nullptr;

    if (mHoverItem == actor)
        mHoverItem = nullptr;
}

void Viewport::cleanHoverItems()
{
    mHoverBeing = nullptr;
    mHoverItem = nullptr;
    mHoverSign = nullptr;
}

void Viewport::moveCamera(const int dx, const int dy)
{
    mCameraRelativeX += dx;
    mCameraRelativeY += dy;
}

bool Viewport::isPopupMenuVisible() const
{
    return mPopupMenu ? mPopupMenu->isPopupVisible() : false;
}

void Viewport::moveCameraToActor(const int actorId,
                                 const int x, const int y)
{
    if (!player_node || !actorManager)
        return;

    const Actor *const actor = actorManager->findBeing(actorId);
    if (!actor)
        return;
    const Vector &actorPos = actor->getPosition();
    const Vector &playerPos = player_node->getPosition();
    mCameraMode = 1;
    mCameraRelativeX = actorPos.x - playerPos.x + x;
    mCameraRelativeY = actorPos.y - playerPos.y + y;
}

void Viewport::moveCameraToPosition(const int x, const int y)
{
    if (!player_node)
        return;

    const Vector &playerPos = player_node->getPosition();
    mCameraMode = 1;

    mCameraRelativeX = x - playerPos.x;
    mCameraRelativeY = y - playerPos.y;
}

void Viewport::moveCameraRelative(const int x, const int y)
{
    mCameraMode = 1;
    mCameraRelativeX += x;
    mCameraRelativeY += y;
}

void Viewport::returnCamera()
{
    mCameraMode = 0;
    mCameraRelativeX = 0;
    mCameraRelativeY = 0;
}

void Viewport::validateSpeed()
{
    if (!inputManager.isActionActive(static_cast<int>(
        Input::KEY_TARGET_ATTACK)) && !inputManager.isActionActive(
        static_cast<int>(Input::KEY_ATTACK)))
    {
        if (Game::instance())
            Game::instance()->setValidSpeed();
    }
}

void Viewport::clearPopup()
{
    if (mPopupMenu)
        mPopupMenu->clear();
}