#include "PlayerComponent.h"
#include "PlayerStates.h"
#include "AnimatedTextureComponent.h"
#include "ISoundSystem.h"
#include "GameObject.h"
#include "GameEvents.h"
#include "LevelComponent.h"

namespace dae
{
    // *******************
    // PLAYER FROZEN STATE
    // *******************
    void PlayerFrozenState::Enter(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->GetGameObject()->SetActive(true);
        if (pPlayerComp->m_pLevelComponent && pPlayerComp->m_pLevelComponent->GetLevelId() == 1)
        {
            pPlayerComp->m_Lives = pPlayerComp->m_MaxLives;
            pPlayerComp->NotifyObservers(PlayerEvents::REVIVED_AFTER_GAMEOVER);
        }

        m_FreezeTimer = m_FreezeDuration;
    }
    void PlayerFrozenState::Update(PlayerComponent* pPlayerComp, float deltaTime)
    {
        if (m_FreezeTimer > 0)
        {
            m_FreezeTimer -= deltaTime;
            return;
        }

        pPlayerComp->ChangeState(IDLE);
    }

    void PlayerFrozenState::Exit(PlayerComponent*) { }
    void PlayerFrozenState::Move(PlayerComponent*, float, float) { }
    void PlayerFrozenState::ShootBubble(PlayerComponent*) { }

    // *****************
    // PLAYER IDLE STATE
    // *****************
    void PlayerIdleState::Enter(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->GetAnimComp()->SetSpritesPerSecond(1);
        pPlayerComp->GetAnimComp()->Play(0, 0);
    }

    void PlayerIdleState::Update(PlayerComponent* pPlayerComp, float deltaTime)
    { 
        pPlayerComp->HandleMovement(deltaTime);
    }
    void PlayerIdleState::Exit(PlayerComponent*) { }

    void PlayerIdleState::Move(PlayerComponent* pPlayerComp, float dirX, float dirY)
    {
        // flip sprite?
        pPlayerComp->ChangeDirection(dirX, dirY);
        
        // set current x movement speed
        pPlayerComp->SetCurrentXSpeed(dirX * pPlayerComp->GetMoveSpeed());

        // set current y movement speed
        if (fabs(dirY) > FLT_EPSILON)
        {
            pPlayerComp->GetSoundSystem()->Play(2, 1.f);

            pPlayerComp->SetCurrentYSpeed(- dirY * pPlayerComp->GetJumpSpeed());
            pPlayerComp->ChangeState(JUMPING);
        }

        // Idle => Running
        if (fabs(dirX) > FLT_EPSILON)
        {
            pPlayerComp->ChangeState(RUNNING);
        }
    }

    void PlayerIdleState::ShootBubble(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->GetSoundSystem()->Play(3, 1.f);
        pPlayerComp->ChangeState(SHOOT_BUBBLE);
    }

    // ********************
    // PLAYER RUNNING STATE
    // ********************
    void PlayerRunningState::Enter(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->GetAnimComp()->SetSpritesPerSecond(16);
        pPlayerComp->GetAnimComp()->Play(1, 4);
    }

    void PlayerRunningState::Update(PlayerComponent* pPlayerComp, float deltaTime)
    {
        if (!pPlayerComp->GetIsGrounded())
        {
            pPlayerComp->ChangeState(FALLING);
        }
        else if (fabs(pPlayerComp->GetCurrentXSpeed()) < FLT_EPSILON)
        {
            pPlayerComp->ChangeState(IDLE);
        }

        pPlayerComp->HandleMovement(deltaTime);
    }

    void PlayerRunningState::Exit(PlayerComponent*) { }

    void PlayerRunningState::ShootBubble(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->GetSoundSystem()->Play(3, 1.f);
        pPlayerComp->ChangeState(SHOOT_BUBBLE);
    }

    void PlayerRunningState::Move(PlayerComponent* pPlayerComp, float dirX, float dirY)
    {
        // flip sprite?
        pPlayerComp->ChangeDirection(dirX, dirY);

        // set current x movement speed
        pPlayerComp->SetCurrentXSpeed(dirX * pPlayerComp->GetMoveSpeed());

        // set current y movement speed
        if (fabs(dirY) > FLT_EPSILON)
        {
            pPlayerComp->GetSoundSystem()->Play(2, 1.f);

            pPlayerComp->SetCurrentYSpeed(-dirY * pPlayerComp->GetJumpSpeed());
            pPlayerComp->ChangeState(JUMPING);
        }
    }

    // ********************
    // PLAYER JUMPING STATE
    // ********************
    void PlayerJumpingState::Enter(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->SetIsGrounded(false);
        pPlayerComp->GetAnimComp()->SetSpritesPerSecond(8);
        pPlayerComp->GetAnimComp()->Play(5, 6);
    }

    void PlayerJumpingState::Update(PlayerComponent* pPlayerComp, float deltaTime)
    {
        if (pPlayerComp->GetCurrentYSpeed() > 0)
        {
            pPlayerComp->ChangeState(FALLING);
        }

        pPlayerComp->HandleMovement(deltaTime);
    }
    
    void PlayerJumpingState::Exit(PlayerComponent* ) { }

    void PlayerJumpingState::ShootBubble(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->GetSoundSystem()->Play(3, 1.f);
        pPlayerComp->ChangeState(SHOOT_BUBBLE);
    }

    void PlayerJumpingState::Move(PlayerComponent* pPlayerComp, float dirX, float dirY)
    {
        // flip sprite?
        pPlayerComp->ChangeDirection(dirX, dirY);

        // set current x movement speed
        pPlayerComp->SetCurrentXSpeed(dirX * pPlayerComp->GetMoveSpeed());
    }

    // ********************
    // PLAYER FALLING STATE
    // ********************
    void PlayerFallingState::Enter(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->GetAnimComp()->SetSpritesPerSecond(8);
        pPlayerComp->GetAnimComp()->Play(7, 8);
    }

    void PlayerFallingState::Update(PlayerComponent* pPlayerComp, float deltaTime)
    {
        if (pPlayerComp->GetIsGrounded())
        {
            pPlayerComp->ChangeState(IDLE);
        }

        pPlayerComp->HandleMovement(deltaTime);
    }

    void PlayerFallingState::Exit(PlayerComponent* ) { }

    void PlayerFallingState::ShootBubble(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->GetSoundSystem()->Play(3, 1.f);
        pPlayerComp->ChangeState(SHOOT_BUBBLE);
    }

    void PlayerFallingState::Move(PlayerComponent* pPlayerComp, float dirX, float dirY)
    {
        // flip sprite?
        pPlayerComp->ChangeDirection(dirX, dirY);

        // set current x movement speed
        pPlayerComp->SetCurrentXSpeed(dirX * pPlayerComp->GetMoveSpeed() / 1.75f);
    }

    // ******************************
    // PLAYER TRAPPED IN BUBBLE STATE
    // ******************************
    void PlayerInBubbleState::Enter(PlayerComponent* ) { }
    void PlayerInBubbleState::Update(PlayerComponent* , float ) { }
    void PlayerInBubbleState::Exit(PlayerComponent* ) { }
    void PlayerInBubbleState::Move(PlayerComponent*, float, float) { }
    void PlayerInBubbleState::ShootBubble(PlayerComponent*) { }

    // ****************************
    // PLAYER SHOOTING BUBBLE STATE
    // ****************************
    void PlayerShootingBubbleState::Enter(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->SetShootTimer(0);
        pPlayerComp->GetAnimComp()->SetSpritesPerSecond(12);
        pPlayerComp->GetAnimComp()->Play(9, 12);

        pPlayerComp->SpawnBubble();
    }

    void PlayerShootingBubbleState::Update(PlayerComponent* pPlayerComp, float deltaTime)
    {
        pPlayerComp->SetShootTimer(pPlayerComp->GetShootTimer() + deltaTime);
        if (pPlayerComp->GetShootTimer() >= pPlayerComp->GetShootDuration())
        {
            pPlayerComp->SetShootTimer(0);
            
            if (!pPlayerComp->GetIsGrounded())
            {
                if (pPlayerComp->GetCurrentYSpeed() > 0)
                {
                    pPlayerComp->ChangeState(FALLING);
                }
                else
                {
                    pPlayerComp->ChangeState(JUMPING);
                }
            }
            else if (fabs(pPlayerComp->GetCurrentXSpeed() > 0))
            {
                pPlayerComp->ChangeState(RUNNING);
            }
            else
            {
                pPlayerComp->ChangeState(IDLE);
            }
        }

        pPlayerComp->HandleMovement(deltaTime);
    }

    void PlayerShootingBubbleState::Exit(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->SetShootTimer(0);
    }

    void PlayerShootingBubbleState::ShootBubble(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->GetSoundSystem()->Play(3, 1.f);
        pPlayerComp->ChangeState(SHOOT_BUBBLE);
    }

    void PlayerShootingBubbleState::Move(PlayerComponent* pPlayerComp, float dirX, float dirY)
    {
        // flip sprite?
        pPlayerComp->ChangeDirection(dirX, dirY);

        // set current x movement speed
        pPlayerComp->SetCurrentXSpeed(dirX * pPlayerComp->GetMoveSpeed());

        // set current y movement speed
        if (fabs(dirY) > FLT_EPSILON && pPlayerComp->GetIsGrounded())
        {
            pPlayerComp->GetSoundSystem()->Play(2, 1.f);

            pPlayerComp->SetCurrentYSpeed(-dirY * pPlayerComp->GetJumpSpeed());
            pPlayerComp->ChangeState(JUMPING);
        }
    }

    // *****************
    // PLAYER DEAD STATE
    // *****************
    void PlayerDeadState::Enter(PlayerComponent* pPlayerComp)
    {
        pPlayerComp->GetSoundSystem()->Play(4, 0.5f);
        m_DidTryRespawning = false;

        pPlayerComp->SetCurrentXSpeed(0);
        pPlayerComp->SetCurrentYSpeed(0);

        m_DeathTimer = m_DeathDuration;
        pPlayerComp->GetAnimComp()->SetSpritesPerSecond(8);
        pPlayerComp->GetAnimComp()->Play(13, 23, true);
    }

    void PlayerDeadState::Update(PlayerComponent* pPlayerComp, float deltaTime)
    {
        if (m_DidTryRespawning)
            return;

        if (m_DeathTimer > 0)
        {
            m_DeathTimer -= deltaTime;
            return;
        }
        m_DidTryRespawning = true;

        if (pPlayerComp->TryRespawn()) pPlayerComp->ChangeState(IDLE);
    }

    void PlayerDeadState::Exit(PlayerComponent*)
    {
        
    }

    void PlayerDeadState::Move(PlayerComponent*, float, float) { }
    void PlayerDeadState::ShootBubble(PlayerComponent* ) { }
}