#include "GameProject_precompiled.h"
#pragma optimize("", off)



#include <AzCore/Component/Entity.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/Serialization/EditContext.h>
#include <AzCore/RTTI/BehaviorContext.h>

/// EBUS
#include <AzCore/Component/TransformBus.h>
#include <AzCore/Component/ComponentApplicationBus.h>

#include <AzFramework/Entity/EntityContextBus.h>
#include <AzFramework/Entity/GameEntityContextBus.h>


/// Game Headers
#include "TerraformingComponent.h"

using namespace GameProject;

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

    if (serialize)
    {
        serialize->Class<TerraformingComponent, AZ::Component >()
            ->Version(1)
            ->Field("radius", &TerraformingComponent::m_radius)
            ->Field("inland", &TerraformingComponent::m_inland)
            ->Field("wholeTerrainNoise", &TerraformingComponent::m_wholeTerrainNoise)
            ->Field("saveAndRestoreOriginalTerrain", &TerraformingComponent::m_saveAndRestoreOriginalTerrain)
            ;

        AZ::EditContext* edit = serialize->GetEditContext();
        if (edit)
        {
            edit->Class<TerraformingComponent>("TerraformingComponent", "")
                ->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))
                ->DataElement(AZ::Edit::UIHandlers::Default, &TerraformingComponent::m_saveAndRestoreOriginalTerrain, "Save and restore original terrain", "")
                ->DataElement(AZ::Edit::UIHandlers::Default, &TerraformingComponent::m_radius, "Radius", "Crater radius around entity")
                ->DataElement(AZ::Edit::UIHandlers::Default, &TerraformingComponent::m_inland, "Inland", "How deep it's should be")
                ->DataElement(AZ::Edit::UIHandlers::Default, &TerraformingComponent::m_wholeTerrainNoise, "Set noise on whole terrain", "")

                ;
        }
    }
}

void TerraformingComponent::Init()
{

}

void TerraformingComponent::Activate()
{
    //AZ::EntityBus::Handler::BusConnect(GetEntityId());
    AzFramework::GameEntityContextEventBus::Handler::BusConnect();
    TerraformingBus::Handler::BusConnect(GetEntityId());
}

void TerraformingComponent::Deactivate()
{


    //AZ::TickBus::Handler::BusDisconnect();
    //AZ::EntityBus::Handler::BusDisconnect(GetEntityId());
    AzFramework::GameEntityContextEventBus::Handler::BusDisconnect();
    TerraformingBus::Handler::BusDisconnect();
}

void TerraformingComponent::OnTick(float deltaTime, AZ::ScriptTimePoint time)
{

}

void TerraformingComponent::OnGameEntitiesStarted()
{
    //if (m_saveAndRestoreOriginalTerrain)
    SaveOriginalTerrain();

    //AZ::TickBus::Handler::BusConnect();
    if (m_wholeTerrainNoise)
        UpdateTerrain();
    else
        //UpdateTerrainUnderEntity(m_radius, m_inland);
        UpdateTerrainUnderEntityOptimized(m_radius, m_inland);
}

void TerraformingComponent::OnGameEntitiesReset()
{
    if (m_saveAndRestoreOriginalTerrain)
        RestoreOriginalTerrain();

    if (pOriginalTerrain)
    {
        delete[] pOriginalTerrain;
        pOriginalTerrain = nullptr;
    }

    if (pCurTerrain)
    {
        delete[] pCurTerrain;
        pCurTerrain = nullptr;
    }

    if (pCurTerrainSW)
    {
        delete[] pCurTerrainSW;
        pCurTerrainSW = nullptr;
    }
}

void TerraformingComponent::UpdateTerrain()
{
    // turn-on terrain deformations
    ICVar* e_td = gEnv->pConsole->GetCVar("e_TerrainDeformations");
    if (e_td)
        e_td->Set(1.0f);

    AZ::u32 mapSize = gEnv->p3DEngine->GetTerrainSize() / gEnv->p3DEngine->GetHeightMapUnitSize(); // = 1024...
    AZ::u32 sectorSize = gEnv->p3DEngine->GetTerrainSectorSize(); // = 32

    float* pTerrainBlock = new float[mapSize*mapSize];
    ITerrain::SurfaceWeight* pTerrainSW  = new ITerrain::SurfaceWeight[mapSize*mapSize];
    ITerrain::SurfaceWeight defaultSW; //= gEnv->p3DEngine->GetITerrain()->GetSurfaceWeight(512, 512); // Sample center of the map for SurfaceWeight for propagate

    // change whole map with random noise
    for (int x = 0; x < mapSize; x++)
    {
        for (int y = 0; y < mapSize; y++)
        {
            pTerrainBlock[x * mapSize + y] = gEnv->p3DEngine->GetTerrainElevation((float)x, (float)y) + m_RndGenerator.GetRandomFloat() * 5.0f;
            pTerrainSW[x * mapSize + y] = defaultSW;
        }
    }

    AZ::Vector3 pos;
    AZ::TransformBus::EventResult(pos, GetEntityId(), &AZ::TransformBus::Events::GetWorldTranslation);
    gEnv->p3DEngine->GetITerrain()->SetTerrainElevation(0, 0 , mapSize, pTerrainBlock, sizeof(pTerrainSW), pTerrainSW);

    delete[] pTerrainBlock;
    delete[] pTerrainSW;
}

//
void TerraformingComponent::UpdateTerrainUnderEntity(float radius, float inland)
{
    // turn-on terrain deformations
    ICVar* e_td = gEnv->pConsole->GetCVar("e_TerrainDeformations");
    if (e_td)
        e_td->Set(1.0f);

    AZ::u32 mapSize = gEnv->p3DEngine->GetTerrainSize() / gEnv->p3DEngine->GetHeightMapUnitSize(); // = 1024...
    AZ::u32 sectorSize = gEnv->p3DEngine->GetTerrainSectorSize(); // = 32 (32 * 32 = 1024 mapsize)

    float* pTerrainBlock = new float[mapSize*mapSize];
    ITerrain::SurfaceWeight* pTerrainSW = new ITerrain::SurfaceWeight[mapSize * mapSize];
    ITerrain::SurfaceWeight defaultSW; //= gEnv->p3DEngine->GetITerrain()->GetSurfaceWeight(512, 512); // Sample center of the map for SurfaceWeight for propagate

    AZ::Vector3 pos;
    AZ::TransformBus::EventResult(pos, GetEntityId(), &AZ::TransformBus::Events::GetWorldTranslation);

    for (int x = 0; x < mapSize; x++)
    {
        for (int y = 0; y < mapSize; y++)
        {
            float terrainZ = gEnv->p3DEngine->GetTerrainElevation((float)x, (float)y);
            float distance = pos.GetDistance(AZ::Vector3((float)x, (float)y, terrainZ));
            float normalizedAffectOnTerrainOverDistance = 1.0f - AZ::GetClamp<float>(distance / radius, 0.0f, 1.0f);

            pTerrainBlock[x * mapSize + y] = terrainZ + (-inland * normalizedAffectOnTerrainOverDistance);
            pTerrainSW[x * mapSize + y] = defaultSW;
        }
    }

    gEnv->p3DEngine->GetITerrain()->SetTerrainElevation(0, 0, mapSize, pTerrainBlock, sizeof(pTerrainSW), pTerrainSW);
    delete[] pTerrainBlock;
    delete[] pTerrainSW;
}

void TerraformingComponent::UpdateTerrainUnderEntityOptimized(float radius, float inland)
{
    // turn-on terrain deformations
    ICVar* e_td = gEnv->pConsole->GetCVar("e_TerrainDeformations");
    if (e_td)
        e_td->Set(1.0f);

    AZ::u32 mapSize = gEnv->p3DEngine->GetTerrainSize() / gEnv->p3DEngine->GetHeightMapUnitSize(); // = 1024...
    AZ::u32 sectorSize = gEnv->p3DEngine->GetTerrainSectorSize(); // = 32 (32 * 32 = 1024 mapsize)

    float* pTerrainBlock = new float[mapSize*mapSize];
    //float* pTerrainBlock = new float[sectorSize*sectorSize];

    ITerrain::SurfaceWeight* pTerrainSW = new ITerrain::SurfaceWeight[mapSize * mapSize];
    //ITerrain::SurfaceWeight* pTerrainSW = new ITerrain::SurfaceWeight[sectorSize * sectorSize];


    ITerrain::SurfaceWeight defaultSW; //= gEnv->p3DEngine->GetITerrain()->GetSurfaceWeight(512, 512); // Sample center of the map for SurfaceWeight for propagate

    // get entity world pos
    AZ::Vector3 pos;
    AZ::TransformBus::EventResult(pos, GetEntityId(), &AZ::TransformBus::Events::GetWorldTranslation);

    // calc cell of map where is entity placed
    int cx = (int)pos.GetX() / sectorSize;
    int cy = (int)pos.GetY() / sectorSize;

    int ccx = cx * sectorSize;
    int ccy = cy * sectorSize;

    for (int x = ccx; x < ccx + sectorSize; x++)
    {
        for (int y = ccy; y < ccy + sectorSize; y++)
        {
            float terrainZ = gEnv->p3DEngine->GetTerrainElevation((float)x, (float)y);
            float distance = pos.GetDistance(AZ::Vector3((float)x, (float)y, terrainZ));
            float normalizedAffectOnTerrainOverDistance = 1.0f - AZ::GetClamp<float>(distance / radius, 0.0f, 1.0f);

            pTerrainBlock[x * mapSize + y] = terrainZ + (-inland * normalizedAffectOnTerrainOverDistance);
            pTerrainSW[x * mapSize + y] = defaultSW;
        }
    }

    gEnv->p3DEngine->GetITerrain()->SetTerrainElevation(ccx, ccy, 32, pTerrainBlock, sizeof(pTerrainSW), pTerrainSW);
    delete[] pTerrainBlock;
    delete[] pTerrainSW;
}

void TerraformingComponent::UpdateTerrainCutout(AZ::Vector3 pos, float radius, bool cutout)
{
    ICVar* e_td = gEnv->pConsole->GetCVar("e_TerrainDeformations");
    if (e_td)
        e_td->Set(1.0f);

    //gEnv->p3DEngine->GetITerrain()->SetOceanWaterLevel(0.0f);

    AZ::u32 mapSize = gEnv->p3DEngine->GetTerrainSize() / gEnv->p3DEngine->GetHeightMapUnitSize(); // = 1024...
    AZ::u32 sectorSize = gEnv->p3DEngine->GetTerrainSectorSize(); // = 32 (32 * 32 = 1024 mapsize)

    //float* pTerrainBlock = new float[mapSize*mapSize];
    //float* pTerrainBlock = new float[sectorSize*sectorSize];

    //ITerrain::SurfaceWeight* pTerrainSW = new ITerrain::SurfaceWeight[mapSize * mapSize];
    //ITerrain::SurfaceWeight* pTerrainSW = new ITerrain::SurfaceWeight[sectorSize * sectorSize];


    ITerrain::SurfaceWeight defaultSW; //= gEnv->p3DEngine->GetITerrain()->GetSurfaceWeight(512, 512); // Sample center of the map for SurfaceWeight for propagate

    //AZ::Vector3 pos;
    //AZ::TransformBus::EventResult(pos, GetEntityId(), &AZ::TransformBus::Events::GetWorldTranslation);

    int doubleRadius = (int)radius * 2;
    int sectorSizeHalf = (int)sectorSize / 2;

    int cx = (int)(pos.GetX()) / sectorSize;
    int cy = (int)(pos.GetY()) / sectorSize;

    int ccx = cx * sectorSize;
    int ccy = cy * sectorSize;

    // cutout terrain
    for (int x = ccx; x < (ccx + sectorSize); x++)
    {
        for (int y = ccy; y < (ccy + sectorSize); y++)
        {
            //float terrainZ = gEnv->p3DEngine->GetTerrainElevation((float)x, (float)y);
            float terrainZ = pCurTerrain[x * mapSize + y];
            float distance = pos.GetDistance(AZ::Vector3((float)x, (float)y, terrainZ));
            float normalizedAffectOnTerrainOverDistance = 1.0f - AZ::GetClamp<float>(distance / radius, 0.0f, 1.0f);

            pCurTerrain[x * mapSize + y] = terrainZ + (-radius * normalizedAffectOnTerrainOverDistance);
        }
    }

    //// smooth terrain
    //const int smoothHalfSize = 4;
    //int tx = 0;
    //int ty = 0;
    //float total = 0.0f;
    //int sampleCount = 0;

    //for (int x = ccx-doubleRadius; x < ccx + doubleRadius; x++)
    //{
    //  for (int y = ccy-doubleRadius; y < ccy + doubleRadius; y++)
    //  {
    //      total = 0.0f;
    //      sampleCount = 0;
    //      for (int xx = -smoothHalfSize; xx < smoothHalfSize; xx++)
    //          for (int yy = -smoothHalfSize; yy < smoothHalfSize; yy++)
    //          {
    //              tx = x + xx;
    //              ty = y + yy;
    //              total +=pCurTerrain[tx * mapSize + tx];
    //              sampleCount++;
    //          }

    //      pCurTerrain[x * mapSize + y] = total / sampleCount;
    //  }
    //}



    gEnv->p3DEngine->GetITerrain()->SetTerrainElevation(ccx, ccy, sectorSize, pCurTerrain, sizeof(pCurTerrainSW), pCurTerrainSW);
    //delete[] pTerrainBlock;
    //delete[] pTerrainSW;
}

void TerraformingComponent::SaveOriginalTerrain()
{
    AZ::u32 mapSize = gEnv->p3DEngine->GetTerrainSize() / gEnv->p3DEngine->GetHeightMapUnitSize(); // = 1024...

    //if (pOriginalTerrain)
    //  delete[] pOriginalTerrain;

    if (!pOriginalTerrain)
        pOriginalTerrain = new float[mapSize*mapSize];

    //SHotUpdateInfo hui;// xd
    ///gEnv->p3DEngine->GetITerrain()->GetCompiledData((char*)pOriginalTerrain, mapSize*mapSize*4, nullptr, nullptr, nullptr, false, )

    if (!pCurTerrain)
        pCurTerrain = new float[mapSize*mapSize];

    if (!pCurTerrainSW)
        pCurTerrainSW = new ITerrain::SurfaceWeight[mapSize * mapSize];

    for (int x = 0; x < mapSize; x++)
    {
        for (int y = 0; y < mapSize; y++)
        {
            pOriginalTerrain[x * mapSize + y] = gEnv->p3DEngine->GetTerrainElevation((float)x, (float)y);
            pCurTerrain[x * mapSize + y] = pOriginalTerrain[x * mapSize + y];
            pCurTerrainSW[x * mapSize + y] = gEnv->p3DEngine->GetITerrain()->GetSurfaceWeight(x, y);
            // Optionaly we also can save gEnv->p3DEngine->GetITerrain()->GetSurfaceWeight(x, y)
        }
    }



    //memcpy(pCurTerrain, pOriginalTerrain, sizeof(pOriginalTerrain));
}

void TerraformingComponent::RestoreOriginalTerrain()
{
    AZ::u32 mapSize = gEnv->p3DEngine->GetTerrainSize() / gEnv->p3DEngine->GetHeightMapUnitSize(); // = 1024...
    gEnv->p3DEngine->GetITerrain()->SetTerrainElevation(0, 0, mapSize, pOriginalTerrain, 0, nullptr);
}