#include "LyTanks_precompiled.h"

#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/Serialization/EditContext.h>

#include "..\..\..\LmbrCentral\Code\Source\Rendering\MeshComponent.h"
#include "AzFramework\Components\TransformComponent.h"

#include <AzCore/Asset/AssetManagerBus.h>
#include <AzCore/Slice/SliceComponent.h>
#include <LmbrCentral/Rendering/MeshAsset.h>
#include <LmbrCentral/Rendering/MaterialAsset.h>

// EBUS
#include <AzCore/Component/TransformBus.h>
#include <AzCore/Component/ComponentApplicationBus.h>
#include <AzFramework/Entity/EntityContextBus.h>
#include <AzFramework/Entity/GameEntityContextBus.h>
#include <LmbrCentral\Rendering\MeshComponentBus.h>
#include <LmbrCentral\Rendering\MaterialOwnerBus.h>
#include <math.h>

#include "MeshComposedComponent.h"

using namespace LyTanks;

void MeshComposedComponent::Reflect(AZ::ReflectContext * context)
{
    AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);

    if (serialize)
    {
        serialize->Class<MeshComposedComponent, AZ::Component >()
            ->Version(1);

        AZ::EditContext* edit = serialize->GetEditContext();
        if (edit)
        {
            edit->Class<MeshComposedComponent>("MeshComposedComponent", "")
                ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
                ->Attribute(AZ::Edit::Attributes::Category, CATEGORY)
                ->Attribute("Icon", "Editor/Icons/Components/ComponentPlaceholder.png")
                ->Attribute("ViewportIcon", "Editor/Icons/Components/Viewport/ComponentPlaceholder.png")
                ->Attribute("AutoExpand", true)
                ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC("Game", 0x232b318c));
        }
    }
}

void MeshComposedComponent::Init()
{

}

void MeshComposedComponent::Activate()
{
    AZ::TickBus::Handler::BusConnect();
    AZ::EntityBus::MultiHandler::BusConnect(GetEntityId());
}

void MeshComposedComponent::Deactivate()
{
    AZ::TickBus::Handler::BusDisconnect();
    AZ::EntityBus::MultiHandler::BusDisconnect(GetEntityId());
}

void MeshComposedComponent::OnTick(float deltaTime, AZ::ScriptTimePoint time)
{
    for(int i=0; i< m_childs.size(); i++)
    {
        m_childsPhase[i] += deltaTime;
        m_childs[i]->GetTransform()->SetWorldTranslation(m_childsPosition[i] + AZ::Vector3(sin(m_childsPhase[i])* 3.f, 0.f, 0.f));
    }
}

void MeshComposedComponent::OnEntityActivated(const AZ::EntityId & entityId)
{
    using namespace LmbrCentral;
    using namespace AzFramework;

    if (m_entity->GetId() == entityId) // if this for owner
    {
        LoadMeshAsset();
        InitializeChildEntities();

    }
    else // for childs
    {
        AZ::Entity* child = nullptr;
        EBUS_EVENT_RESULT(child, AZ::ComponentApplicationBus, FindEntity, entityId);

        if (child)
        {

        }
    }
}

void MeshComposedComponent::OnEntityDeactivated(const AZ::EntityId & entityId)
{
    for (AZStd::shared_ptr<AZ::Entity> childs : m_childs)
    {
        AZ::EntityBus::MultiHandler::BusDisconnect(childs->GetId());
        childs.reset();
    }
}

void MeshComposedComponent::InitializeChildEntities()
{
    using namespace LmbrCentral;
    using namespace AzFramework;

    if (m_isInitialized)
    {
        m_childs.clear();
        m_childsPosition.clear();
        m_childsPhase.clear();
    }

    m_childs.resize(TypeElement::MAX_ELEMENT);
    m_childsPosition.resize(TypeElement::MAX_ELEMENT);
    m_childsPhase.resize(TypeElement::MAX_ELEMENT);

    for (int i = 0; i < m_childs.size(); ++i)
    {
        m_childs[i] = AZStd::make_shared<AZ::Entity>("ChildEntity" + ToString(i));
        if (m_childs[i])
        {
            // Before child entity activation create all necessary components
            AzFramework::TransformComponent* transform = azdynamic_cast<TransformComponent*>(m_childs[i]->CreateComponent(AZ::TransformComponentTypeId));
            if (transform)
            {
                AZ::Vector3 pos = m_entity->GetTransform()->GetWorldTranslation();
                AZ::TransformConfig conf;
                conf.m_isStatic = false;
                m_childsPosition[i] = pos + AZ::Vector3(0, 0, i * 2.0f);
                m_childsPhase[i] = i*10.0f;

                conf.m_worldTransform = AZ::Transform::CreateTranslation(m_childsPosition[i]);
                conf.m_netSyncEnabled = false;
                conf.m_parentId = m_entity->GetId();
                conf.m_parentActivationTransformMode = AZ::TransformConfig::ParentActivationTransformMode::MaintainCurrentWorldTransform;
                conf.m_interpolatePosition = AZ::InterpolationMode::LinearInterpolation;
                conf.m_interpolatePosition = AZ::InterpolationMode::LinearInterpolation;

                transform->SetConfiguration(conf);
            }

            LmbrCentral::MeshComponent* mesh = azdynamic_cast<MeshComponent*>(m_childs[i]->CreateComponent(AZ::AzTypeInfo<LmbrCentral::MeshComponent>::Uuid()));
            if (mesh)
            {
                if (meshAsset.GetId().IsValid())
                {
                    mesh->Activate();
                    mesh->SetMeshAsset(meshAsset.GetId());
                    mesh->SetVisibility(true);
                    mesh->SetMaterial(m_materialOverride);
                    //LmbrCentral::MaterialOwnerRequestBus::Event(m_rawCameraRig[i]->GetId(), &LmbrCentral::MaterialOwnerRequestBus::Events::SetMaterial, m_materialOverride);
                }
            }

            // Can't add component while the entity is active!
            m_childs[i]->Init();
            m_childs[i]->Activate();

            // Owner Entity(parent entity) subscribs for the child's EntityBus events (activate/deactivate)
            AZ::EntityBus::MultiHandler::BusConnect(m_childs[i]->GetId());
        }
    }
    m_isInitialized = true;
}

void MeshComposedComponent::LoadMeshAsset()
{
    using namespace LmbrCentral;
    // 1. load material
    const AZStd::string& materialOverridePath = "Objects\\default\\box1x1_green.mtl"; //"objects/default/editorprimitive.mtl";
    m_materialOverride = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(materialOverridePath.c_str(), true, true, 0);

    AZ_Warning("LoadMeshAsset", m_materialOverride != gEnv->p3DEngine->GetMaterialManager()->GetDefaultMaterial(),
        "Failed to load override Material \"%s\".",
        materialOverridePath.c_str());

    // 2. load mesh
    AZ::Data::AssetId sliceAssetId;
    const AZStd::string fileName = "Objects/default/box1x1.cgf";//"objects/default/primitive_sphere.cgf";
    EBUS_EVENT_RESULT(sliceAssetId, AZ::Data::AssetCatalogRequestBus, GetAssetIdByPath, fileName.c_str(), AZ::AzTypeInfo<AZ::Data::Asset<MeshAsset>>::Uuid(), true);
    //AZ::Data::AssetCatalogRequestBus::BroadcastResult(sliceAssetId, fileName.c_str(), AZ::AzTypeInfo<AZ::Data::Asset<MeshAsset>>::Uuid(), true);
    //AZ::Data::AssetBus::Handler::BusConnect(sliceAssetId);
    if (sliceAssetId.IsValid())
    {
        // Using the valid ID, find the actual slice asset
        meshAsset.Create(sliceAssetId, true);
    }
}