#define OLC_PGE_APPLICATION
#include "pixelGameEngine.h"

// PGEX Require the presence of olc::PixelGameEngine
#define OLC_PGEX_QUICKGUI
#include "quickgui.h"

namespace olc::QuickGUI{
    class PictureBox : public olc::QuickGUI::BaseControl{
        private:
            olc::vi2d clickPos;
        public:
            PictureBox(olc::QuickGUI::Manager& manager, // Associate with a Manager
                const olc::vf2d& pos,
                const olc::vf2d& size,
                const olc::vf2d& offset,
                olc::Renderable& image);

        public:
            // Minium value
            olc::vf2d offset;
            olc::vf2d pos;
            olc::vf2d size;
            olc::Renderableℑ

        public: // BaseControl overrides
            void Update(olc::PixelGameEngine* pge) override;
            void Draw(olc::PixelGameEngine* pge) override;
            void DrawDecal(olc::PixelGameEngine* pge) override;
    };

    PictureBox::PictureBox(olc::QuickGUI::Manager& manager, const olc::vf2d& pos, const olc::vf2d& size, const olc::vf2d& offset,olc::Renderable& image) 
		: BaseControl(manager),pos(pos),size(size),offset(offset),image(image){}

	void PictureBox::Update(olc::PixelGameEngine* pge)
	{
		bPressed = false;
		bReleased = false;
		float fElapsedTime = pge->GetElapsedTime();

		olc::vf2d vMouse = pge->GetMousePos();
		if (m_state != State::Click)
		{
			if (vMouse.x >= pos.x && vMouse.x < pos.x + size.x &&
				vMouse.y >= pos.y && vMouse.y < pos.y + size.y)
			{
				m_fTransition += fElapsedTime * m_manager.fHoverSpeedOn;
				m_state = State::Hover;

				bPressed = pge->GetMouse(olc::Mouse::LEFT).bPressed;				
				if (bPressed)
				{
					m_state = State::Click;
                    clickPos = vMouse;
				}

				bHeld = pge->GetMouse(olc::Mouse::LEFT).bHeld;
			}
			else
			{
				m_fTransition -= fElapsedTime * m_manager.fHoverSpeedOff;
				m_state = State::Normal;
			}
		}
		else
		{	
			bHeld = pge->GetMouse(olc::Mouse::LEFT).bHeld;
			bReleased = pge->GetMouse(olc::Mouse::LEFT).bReleased;
			if (bReleased) m_state = State::Normal;
            offset+=clickPos-vMouse;
            offset.x=std::clamp((int)offset.x,0,image.Sprite()->width-(int)size.x);
            offset.y=std::clamp((int)offset.y,0,image.Sprite()->height-(int)size.y);
            clickPos=vMouse;
		}
	}

	void PictureBox::Draw(olc::PixelGameEngine* pge)
	{
		if (!bVisible)
			return;
		switch (m_state)
		{
            case State::Disabled: {
                pge->FillRect(pos,size,m_manager.colDisable);
            }break;
            case State::Normal:
            case State::Hover: {
                pge->FillRect(pos,size,olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
            }break;
            case State::Click: {
                pge->FillRect(pos,size,m_manager.colClick);
            }break;
		}
        pge->DrawPartialSprite({(int)pos.x+1,(int)pos.y+1},image.Sprite(),offset,{(int)size.x-2,(int)size.y-2});
        pge->DrawRect(pos,size,m_manager.colBorder);
	}

	void PictureBox::DrawDecal(olc::PixelGameEngine* pge)
	{
		if (!bVisible)
			return;

		switch (m_state)
		{
            case State::Disabled: {
                pge->FillRectDecal(pos,size,olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
            }break;
            case State::Normal:
            case State::Hover: {
                pge->FillRectDecal(pos,size,olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
            }break;
            case State::Click: {
                pge->FillRectDecal(pos,size,m_manager.colClick);
            }break;
		}
        pge->DrawPartialDecal({pos.x+1,pos.y+1},image.Decal(),offset,{size.x-2,size.y-2});
        pge->SetDecalMode(olc::DecalMode::WIREFRAME);
        pge->DrawRectDecal(pos,size,m_manager.colBorder);
        pge->SetDecalMode(olc::DecalMode::NORMAL);
	}

}


class olcDemo_QuickGUI : public olc::PixelGameEngine
{
public:
	olcDemo_QuickGUI()
	{
		sAppName = "olcDemo_QuickGUI";
	}

protected:
	olc::QuickGUI::Manager guiManager;

	olc::QuickGUI::PictureBox* pictureBox = nullptr;
	olc::QuickGUI::Slider* pictureBoxSliderX = nullptr;
	olc::QuickGUI::Slider* pictureBoxSliderY = nullptr;
    olc::Renderable dirtimg;

public:
	bool OnUserCreate() override
	{
        dirtimg.Load("dirtblock.png");

		pictureBox = new olc::QuickGUI::PictureBox(guiManager, 
			{ 10.0f, 10.0f }, { 128.0f, 128.0f }, {0,0}, dirtimg);
        pictureBoxSliderX = new olc::QuickGUI::Slider(guiManager,{pictureBox->pos.x,pictureBox->pos.y+pictureBox->size.y+16},{pictureBox->pos.x+pictureBox->size.x,pictureBox->pos.y+pictureBox->size.y+16},
            0,pictureBox->image.Sprite()->width-(int)pictureBox->size.x,pictureBox->offset.x);
        pictureBoxSliderY = new olc::QuickGUI::Slider(guiManager,{pictureBox->pos.x+pictureBox->size.x+16,pictureBox->pos.y},{pictureBox->pos.x+pictureBox->size.x+16,pictureBox->pos.y+pictureBox->size.y},
            0,pictureBox->image.Sprite()->height-(int)pictureBox->size.y,pictureBox->offset.y);

        guiManager.AddControl(pictureBox);
        guiManager.AddControl(pictureBoxSliderX);
		return true;
	}

	bool OnUserUpdate(float fElapsedTime) override
	{
		guiManager.Update(this);

        if (pictureBoxSliderX->bHeld) {
            pictureBox->offset.x=pictureBoxSliderX->fValue;
        } else {
            pictureBoxSliderX->fValue=pictureBox->offset.x;
        }

        if (pictureBoxSliderY->bHeld) {
            pictureBox->offset.y=pictureBoxSliderY->fValue;
        } else {
            pictureBoxSliderY->fValue=pictureBox->offset.y;
        }

		// Draw Stuff!
		Clear(olc::BLACK);

        guiManager.DrawDecal(this);
		return true;
	}
};

int main()
{
	olcDemo_QuickGUI demo;
	if (demo.Construct(256, 240, 4, 4))
		demo.Start();
	return 0;
}