/*
 * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
 * its licensors.
 *
 * For complete copyright and license terms please see the LICENSE at the root of this
 * distribution (the "License"). All use of this software is governed by the License,
 * or, if provided, by the license below or the license accompanying this file. Do not
 * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *
 */

#include "LyShine_precompiled.h"
#include "LyShineLoadScreen.h"

#if AZ_LOADSCREENCOMPONENT_ENABLED

#include <IRenderer.h>

#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/Component/ComponentApplicationBus.h>
#include <LyShine/Bus/UiCanvasBus.h>
#include <LyShine/Animation/IUiAnimation.h>

namespace LyShine
{
    void LyShineLoadScreenComponent::Reflect(AZ::ReflectContext* context)
    {
        if (AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context))
        {
            serialize->Class<LyShineLoadScreenComponent>()
                ->Version(0)
                ;
        }
    }

    void LyShineLoadScreenComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
    {
        provided.emplace_back(AZ_CRC("LyShineLoadScreenService", 0xBB5EAB17));
    }

    void LyShineLoadScreenComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
    {
        incompatible.emplace_back(AZ_CRC("LyShineLoadScreenService", 0xBB5EAB17));
    }

    void LyShineLoadScreenComponent::Init()
    {
    }

    void LyShineLoadScreenComponent::Activate()
    {
        LoadScreenNotificationBus::Handler::BusConnect();
    }

    void LyShineLoadScreenComponent::Deactivate()
    {
        LoadScreenUpdateNotificationBus::Handler::BusDisconnect();
        LoadScreenNotificationBus::Handler::BusDisconnect();
    }

    bool LyShineLoadScreenComponent::NotifyGameLoadStart(bool usingLoadingThread)
    {
        // LyShine does not support the loading thread yet.
        if (usingLoadingThread)
        {
            return false;
        }

        if (!gEnv || !gEnv->pRenderer || !gEnv->pLyShine)
        {
            return false;
        }

        AZ_Assert(!m_isPlaying, "LyShineLoadScreen was somehow started before the engine loaded.");
        if (m_isPlaying)
        {
            return false;
        }

        if (!m_gameCanvasEntityId.IsValid())
        {
            // Load canvas.
            m_gameCanvasEntityId = loadFromCfg("game_load_screen_uicanvas_path", "game_load_screen_sequence_to_auto_play");
        }

        m_isPlaying = m_gameCanvasEntityId.IsValid();

        if (m_isPlaying)
        {
            LoadScreenUpdateNotificationBus::Handler::BusConnect();
        }

        return m_isPlaying;
    }

    bool LyShineLoadScreenComponent::NotifyLevelLoadStart(bool usingLoadingThread)
    {
        // LyShine does not support the loading thread yet.
        if (usingLoadingThread)
        {
            return false;
        }

        if (!gEnv || !gEnv->pRenderer || !gEnv->pLyShine)
        {
            return false;
        }

        AZ_Assert(!m_isPlaying, "LyShineLoadScreen was not stopped before another level load started.");
        AZ_Assert(!m_gameCanvasEntityId.IsValid(), "LyShineLoadScreen game load canvas was not unloaded before a level load started.");
        if (m_isPlaying || m_gameCanvasEntityId.IsValid())
        {
            return false;
        }

        if (!m_levelCanvasEntityId.IsValid())
        {
            // Load canvas.
            m_levelCanvasEntityId = loadFromCfg("level_load_screen_uicanvas_path", "level_load_screen_sequence_to_auto_play");
        }

        m_isPlaying = m_levelCanvasEntityId.IsValid();

        if (m_isPlaying)
        {
            LoadScreenUpdateNotificationBus::Handler::BusConnect();
        }

        return m_isPlaying;
    }

    void LyShineLoadScreenComponent::NotifyLoadEnd()
    {
        Reset();
    }

    void LyShineLoadScreenComponent::UpdateAndRender(float deltaTimeInSeconds)
    {
        AZ_Assert(m_isPlaying, "LyShineLoadScreenComponent should not be connected to LoadScreenUpdateNotificationBus while not playing");

        if (m_isPlaying && gEnv && gEnv->pLyShine && gEnv->pRenderer)
        {
            AZ_Assert(GetCurrentThreadId() == gEnv->mMainThreadId, "UpdateAndRender should only be called from the main thread");

            // update the animation system
            gEnv->pLyShine->Update(deltaTimeInSeconds);

            // Render.
            gEnv->pLyShine->Render();
        }
    }

    void LyShineLoadScreenComponent::LoadThreadUpdate(float deltaTimeInSeconds)
    {
        AZ_Assert(false, "LyShine does not support running on the loading thread yet.")
    }

    void LyShineLoadScreenComponent::LoadThreadRender()
    {
        AZ_Assert(false, "LyShine does not support running on the loading thread yet.")
    }

    void LyShineLoadScreenComponent::Reset()
    {
        LoadScreenUpdateNotificationBus::Handler::BusDisconnect();

        m_isPlaying = false;

        if (gEnv && gEnv->pLyShine)
        {
            AZ::Entity* canvasEntity = nullptr;

            // Release the game canvas.
            if (m_gameCanvasEntityId.IsValid())
            {
                EBUS_EVENT_RESULT(canvasEntity, AZ::ComponentApplicationBus, FindEntity, m_gameCanvasEntityId);
                if (canvasEntity)
                {
                    gEnv->pLyShine->ReleaseCanvas(m_gameCanvasEntityId, false);
                    gEnv->pLyShine->OnLoadScreenUnloaded();
                }
            }

            // Release the level canvas.
            if (m_levelCanvasEntityId.IsValid())
            {
                EBUS_EVENT_RESULT(canvasEntity, AZ::ComponentApplicationBus, FindEntity, m_levelCanvasEntityId);
                if (canvasEntity)
                {
                    gEnv->pLyShine->ReleaseCanvas(m_levelCanvasEntityId, false);
                    gEnv->pLyShine->OnLoadScreenUnloaded();
                }
            }
        }

        m_gameCanvasEntityId.SetInvalid();
        m_levelCanvasEntityId.SetInvalid();

        // Reset CVars so they're not carried over to other levels
        auto ClearCvar = [](const char* cvarName)
        {
            if (gEnv && gEnv->pConsole)
            {
                if (ICVar* var = gEnv->pConsole->GetCVar(cvarName))
                {
                    var->Set("");
                }
            }
        };

        ClearCvar("level_load_screen_uicanvas_path");
        ClearCvar("level_load_screen_sequence_to_auto_play");
    }

    AZ::EntityId LyShineLoadScreenComponent::loadFromCfg(const char* pathVarName, const char* autoPlayVarName)
    {
        ICVar* pathVar = gEnv->pConsole->GetCVar(pathVarName);
        string path = pathVar ? pathVar->GetString() : "";
        if (path.empty())
        {
            // No canvas specified.
            Reset();
            return AZ::EntityId();
        }

        AZ::EntityId canvasId = gEnv->pLyShine->LoadCanvas(path);
        AZ_Warning("LoadScreenComponent", canvasId.IsValid(), "Can't load canvas: %s", path.c_str());
        if (!canvasId.IsValid())
        {
            // Error loading canvas.
            Reset();
            return AZ::EntityId();
        }

        EBUS_EVENT_ID(canvasId, UiCanvasBus, SetKeepLoadedOnLevelUnload, true);

        // Set the load screen draw order so it renders in front of other canvases that may load during the level load
        EBUS_EVENT_ID(canvasId, UiCanvasBus, SetDrawOrder, std::numeric_limits<int>::max());

        ICVar* autoPlayVar = gEnv->pConsole->GetCVar(autoPlayVarName);
        string sequence = autoPlayVar ? autoPlayVar->GetString() : "";
        if (sequence.empty())
        {
            // Nothing to auto-play.
            return canvasId;
        }

        IUiAnimationSystem* animSystem = nullptr;
        EBUS_EVENT_ID_RESULT(animSystem, canvasId, UiCanvasBus, GetAnimationSystem);
        if (!animSystem)
        {
            // Nothing can be auto-played.
            return canvasId;
        }

        animSystem->PlaySequence(sequence, nullptr, false, false);

        return canvasId;
    }

} // namespace LyShine

#endif // AZ_LOADSCREENCOMPONENT_ENABLED