#pragma once

#include "CoreMinimal.h"
#include "Json.h"
#include "VoxelBiomeDefinition.h"
#include "VoxelGenerator.h"
#include "VoxelSettings.h"
#include "VoxelStrateDefinition.h"
#include "VoxelStrateManager.h"
#include "VoxelTerrainOpDefinition.h"

struct FStandaloneParitySample
{
    FVector PositionVoxels;
    float PluginDensity = 0.0f;
    std::string Kind;
    int32 StrateIndex = INDEX_NONE;
};

struct FStandaloneOwnerWorld
{
    std::unique_ptr<UVoxelSettings> Settings;
    std::unique_ptr<UVoxelStrateManager> Manager;
    std::unique_ptr<UVoxelGenerator> Generator;
    std::vector<std::unique_ptr<UVoxelStrateDefinition>> DefinitionStorage;
    std::vector<std::unique_ptr<UVoxelBiomeDefinition>> BiomeStorage;
    std::vector<std::unique_ptr<UVoxelTerrainOpDefinition>> OperationStorage;
    std::vector<FStandaloneParitySample> DensitySamples;
    FVector ViewerStartVoxels = FVector::ZeroVector;
    bool ViewerStartFound = false;
    int32 Seed = 0;
    int32 ClipRadius = 6;
    int32 MaxClipLevel = 8;
    int32 FullResClipLevels = 2;
    int32 CoarseTileCells = 16;
    int32 RenderDistanceChunks = 1536;
    int32 StrateContentCutMinLevel = 9;
    bool bGenerateSkirts = true;
    int32 SkirtCells = 2;
    int32 LODOctaveDrop = 0;
};

namespace StandaloneOwnerLoader
{
    template<class T>
    inline void ReadField(const VFJson::Value& Object, const char* Name, T& Out)
    {
        const VFJson::Value& Value = Object.Get(Name);
        if constexpr (std::is_same_v<T, bool>)
        {
            if (std::holds_alternative<bool>(Value.Data)) Out = Value.Boolean(Out);
            else if (Value.IsNumber()) Out = Value.Number() != 0.0;
        }
        else if constexpr (std::is_enum_v<T>)
        {
            if (Value.IsNumber()) Out = static_cast<T>(Value.Integer());
        }
        else if constexpr (std::is_arithmetic_v<T>)
        {
            if (Value.IsNumber()) Out = static_cast<T>(Value.Number());
        }
    }

    inline void ReadText(const VFJson::Value& Object, const char* Name, FText& Out)
    {
        const VFJson::Value& Value = Object.Get(Name);
        if (Value.IsString()) Out = FText::FromString(FString(Value.String()));
    }

    inline void ReadLinearColor(const VFJson::Value& Object, FLinearColor& Out)
    {
        ReadField(Object, "R", Out.R); ReadField(Object, "G", Out.G);
        ReadField(Object, "B", Out.B); ReadField(Object, "A", Out.A);
    }

    inline void ReadVector(const VFJson::Value& Object, FVector& Out)
    {
        ReadField(Object, "x", Out.X); ReadField(Object, "y", Out.Y); ReadField(Object, "z", Out.Z);
    }

    inline void ReadGenerationParams(const VFJson::Value& J, FStrateGenerationParams& P)
    {
#define VF_LOAD_STRATE_FIELD(Name) ReadField(J, #Name, P.Name);
        VF_STRATE_PARAM_FIELDS(VF_LOAD_STRATE_FIELD, VF_LOAD_STRATE_FIELD)
#undef VF_LOAD_STRATE_FIELD
        ReadField(J, "bTunnelFloorEnabled", P.bTunnelFloorEnabled);
    }

    inline void ReadDisturbances(const VFJson::Value& J, FStrateDisturbanceParams& P)
    {
        ReadField(J,"ChasmDensity",P.ChasmDensity); ReadField(J,"ChasmSpacing",P.ChasmSpacing);
        ReadField(J,"ChasmRadius",P.ChasmRadius); ReadField(J,"BridgeDensity",P.BridgeDensity);
        ReadField(J,"BridgeSpacing",P.BridgeSpacing); ReadField(J,"BridgeRadius",P.BridgeRadius);
        ReadField(J,"RidgeDensity",P.RidgeDensity); ReadField(J,"RidgeSpacing",P.RidgeSpacing);
        ReadField(J,"RidgeHeight",P.RidgeHeight); ReadField(J,"RidgeThickness",P.RidgeThickness);
        ReadField(J,"BaseDensity",P.BaseDensity); ReadField(J,"BoundarySealThickness",P.BoundarySealThickness);
    }

    inline void ReadPassageConfig(const VFJson::Value& J, FStratePassageConfig& P)
    {
        ReadField(J,"Connections",P.Connections); ReadField(J,"Style",P.Style);
        ReadField(J,"MouthRadius",P.MouthRadius); ReadField(J,"MidRadius",P.MidRadius);
        ReadField(J,"ReachMin",P.ReachMin); ReadField(J,"ReachMax",P.ReachMax);
        ReadField(J,"DistanceMin",P.DistanceMin); ReadField(J,"DistanceMax",P.DistanceMax);
        ReadField(J,"Wander",P.Wander); ReadField(J,"Segments",P.Segments);
        ReadField(J,"VerticalWobble",P.VerticalWobble); ReadField(J,"SpiralRadius",P.SpiralRadius);
        ReadField(J,"SpiralTurns",P.SpiralTurns); ReadField(J,"CascadeSteps",P.CascadeSteps);
        ReadField(J,"CascadeLedge",P.CascadeLedge);
    }

    inline void ReadSurfaceParams(const VFJson::Value& J, FSurfaceGenerationParams& P)
    {
#define VF_SURFACE_FIELD(Name) ReadField(J, #Name, P.Name);
        VF_SURFACE_FIELD(BaseGroundRelative) VF_SURFACE_FIELD(ElevationRange)
        VF_SURFACE_FIELD(ContinentFrequency) VF_SURFACE_FIELD(MountainStrength)
        VF_SURFACE_FIELD(MountainFrequency) VF_SURFACE_FIELD(DetailFrequency)
        VF_SURFACE_FIELD(SurfaceRoughness) VF_SURFACE_FIELD(HeightWarpStrength)
        VF_SURFACE_FIELD(HeightWarpFrequency) VF_SURFACE_FIELD(ReliefFrequency)
        VF_SURFACE_FIELD(ReliefStrength) VF_SURFACE_FIELD(ReliefContrast)
        VF_SURFACE_FIELD(TerraceStrength) VF_SURFACE_FIELD(TerraceHeight)
        VF_SURFACE_FIELD(TerraceHardness) VF_SURFACE_FIELD(LayerLineDepth)
        VF_SURFACE_FIELD(LayerLineSpacing) VF_SURFACE_FIELD(CliffStrength)
        VF_SURFACE_FIELD(CliffSlopeThreshold) VF_SURFACE_FIELD(CliffSharpness)
        VF_SURFACE_FIELD(CliffSampleDist) VF_SURFACE_FIELD(OverhangStrength)
        VF_SURFACE_FIELD(OverhangReach) VF_SURFACE_FIELD(OverhangHeight)
        VF_SURFACE_FIELD(OverhangFrequency) VF_SURFACE_FIELD(OverhangZScale)
        VF_SURFACE_FIELD(OverhangSlopeThreshold) VF_SURFACE_FIELD(WaterLevelRelative)
        VF_SURFACE_FIELD(BeachWidth) VF_SURFACE_FIELD(CeilingRelative)
        VF_SURFACE_FIELD(CeilingRoughness) VF_SURFACE_FIELD(CeilingRoughnessFrequency)
        VF_SURFACE_FIELD(CeilingUndulation) VF_SURFACE_FIELD(CeilingUndulationFrequency)
        VF_SURFACE_FIELD(CeilingRidgeStrength) VF_SURFACE_FIELD(CeilingRidgeFrequency)
        VF_SURFACE_FIELD(CeilingWarpStrength) VF_SURFACE_FIELD(CeilingWarpFrequency)
        VF_SURFACE_FIELD(BoundarySealThickness) VF_SURFACE_FIELD(BaseDensity)
#undef VF_SURFACE_FIELD
    }

    inline void ReadBiomeMap(const VFJson::Value& J, FBiomeMapParams& P)
    {
        ReadField(J,"CellSize",P.CellSize); ReadField(J,"WarpStrength",P.WarpStrength);
        ReadField(J,"WarpFrequency",P.WarpFrequency); ReadField(J,"BorderBlend",P.BorderBlend);
        ReadField(J,"ReliefFrequency",P.ReliefFrequency); ReadField(J,"ReliefContrast",P.ReliefContrast);
        ReadField(J,"MoistureFrequency",P.MoistureFrequency);
    }

    inline void ReadOperation(const VFJson::Value& J, UVoxelTerrainOpDefinition& O)
    {
        ReadField(J,"Type",O.Type);
#define VF_OPERATION_FIELD(Name) ReadField(J, #Name, O.Name);
        VF_OPERATION_FIELD(TerraceStepHeight) VF_OPERATION_FIELD(TerraceHardness)
        VF_OPERATION_FIELD(TerraceNoiseDisplacement) VF_OPERATION_FIELD(LayerLineSpacing)
        VF_OPERATION_FIELD(LayerLineDepth) VF_OPERATION_FIELD(RibbingSpacing)
        VF_OPERATION_FIELD(RibbingDepth) VF_OPERATION_FIELD(CliffStrength)
        VF_OPERATION_FIELD(ScallopStrength) VF_OPERATION_FIELD(ScallopFrequency)
        VF_OPERATION_FIELD(OverhangStrength) VF_OPERATION_FIELD(OverhangDepth)
        VF_OPERATION_FIELD(OverhangFrequency) VF_OPERATION_FIELD(ArchDensity)
        VF_OPERATION_FIELD(ArchMinRadius) VF_OPERATION_FIELD(ArchMaxRadius)
        VF_OPERATION_FIELD(ColumnDensity) VF_OPERATION_FIELD(ColumnMinRadius)
        VF_OPERATION_FIELD(ColumnMaxRadius) VF_OPERATION_FIELD(PitDensity)
        VF_OPERATION_FIELD(PitMinRadius) VF_OPERATION_FIELD(PitMaxRadius)
        VF_OPERATION_FIELD(PitDepth) VF_OPERATION_FIELD(ChimneyDensity)
        VF_OPERATION_FIELD(ChimneyMinRadius) VF_OPERATION_FIELD(ChimneyMaxRadius)
        VF_OPERATION_FIELD(ChimneyHeight) VF_OPERATION_FIELD(DomeDensity)
        VF_OPERATION_FIELD(DomeMinRadius) VF_OPERATION_FIELD(DomeMaxRadius)
        VF_OPERATION_FIELD(DomeHeightRatio) VF_OPERATION_FIELD(PinchDensity)
        VF_OPERATION_FIELD(PinchStrength) VF_OPERATION_FIELD(PinchLength)
#undef VF_OPERATION_FIELD
    }

    inline void ReadBiome(const VFJson::Value& J, UVoxelBiomeDefinition& B)
    {
        ReadText(J,"BiomeName",B.BiomeName); ReadText(J,"BiomeDescription",B.BiomeDescription);
        ReadLinearColor(J.Get("DebugColor"),B.DebugColor);
        ReadField(J,"ReliefMin",B.ReliefMin); ReadField(J,"ReliefMax",B.ReliefMax);
        ReadField(J,"MoistureMin",B.MoistureMin); ReadField(J,"MoistureMax",B.MoistureMax);
        ReadField(J,"bOverrideTerrain",B.bOverrideTerrain); ReadField(J,"GeneratorType",B.GeneratorType);
        ReadSurfaceParams(J.Get("SurfaceParams"),B.SurfaceParams);
        ReadField(J,"bOverrideAtmosphere",B.bOverrideAtmosphere);
        ReadLinearColor(J.Get("FogColor"),B.FogColor); ReadField(J,"FogDensity",B.FogDensity);
        ReadLinearColor(J.Get("AmbientLightColor"),B.AmbientLightColor);
        ReadField(J,"AmbientLightIntensity",B.AmbientLightIntensity);
        ReadField(J,"MaterialPaletteIndex",B.MaterialPaletteIndex);
    }

    inline UVoxelStrateDefinition* ReadDefinition(
        FStandaloneOwnerWorld& World, const VFJson::Value& Slot, int32 SlotIndex)
    {
        const VFJson::Value& J = Slot.Get("asset");
        auto Definition = std::make_unique<UVoxelStrateDefinition>();
        ReadText(J,"StrateName",Definition->StrateName);
        ReadText(J,"StrateDescription",Definition->StrateDescription);
        ReadField(J,"StrateHeightInChunks",Definition->StrateHeightInChunks);
        ReadField(J,"TransitionType",Definition->TransitionType);
        ReadField(J,"TransitionBlendChunks",Definition->TransitionBlendChunks);
        ReadField(J,"GeneratorType",Definition->GeneratorType);
        ReadField(J,"bEnableWorms",Definition->bEnableWorms);
        ReadGenerationParams(Slot.Get("generation_params"),Definition->GenerationParams);
        ReadDisturbances(Slot.Get("disturbances"),Definition->Disturbances);
        ReadPassageConfig(Slot.Get("passage_config"),Definition->PassageConfig);
        ReadSurfaceParams(J.Get("SurfaceParams"),Definition->SurfaceParams);
        ReadBiomeMap(J.Get("BiomeMapParams"),Definition->BiomeMapParams);
        ReadField(J,"bHasWater",Definition->bHasWater);

        const auto& Biomes = J.Get("Biomes").AsArray();
        Definition->Biomes.Reserve(static_cast<int32>(Biomes.size()));
        for (const VFJson::Value& BiomeJson : Biomes)
        {
            auto Biome = std::make_unique<UVoxelBiomeDefinition>();
            ReadBiome(BiomeJson,*Biome);
            Definition->Biomes.Add(Biome.get());
            World.BiomeStorage.push_back(std::move(Biome));
        }

        const auto& OperationEntries = Slot.Get("terrain_operation_assets").AsArray();
        Definition->TerrainOperations.Reserve(static_cast<int32>(OperationEntries.size()));
        for (int32 I = 0; I < static_cast<int32>(OperationEntries.size()); ++I)
        {
            const VFJson::Value& EntryJson = OperationEntries[static_cast<size_t>(I)];
            const VFJson::Value& AssetJson = EntryJson.Get("asset");
            const VFJson::Value& PathJson = EntryJson.Get("asset_path");
            const FString Path = PathJson.IsString() ? FString(PathJson.String()) : FString{};
            FStrateTerrainOpEntry Entry;
            ReadField(EntryJson,"weight",Entry.Weight);
            ReadField(EntryJson,"probability",Entry.Probability);
            if (AssetJson.IsObject())
            {
                auto Operation = std::make_unique<UVoxelTerrainOpDefinition>();
                ReadOperation(AssetJson,*Operation);
                UVoxelTerrainOpDefinition* Raw = Operation.get();
                World.OperationStorage.push_back(std::move(Operation));
                Entry.Operation.Set(Raw,Path);
                RegisterStandaloneAsset(Path,Raw);
            }
            else if (!Path.IsEmpty()) Entry.Operation = TSoftObjectPtr<UVoxelTerrainOpDefinition>(Path);
            Definition->TerrainOperations.Add(std::move(Entry));
        }

        const FString SyntheticPath = FString::Printf("/Standalone/Strate_%d",SlotIndex);
        Definition->PostLoad();
        UVoxelStrateDefinition* Raw = Definition.get();
        World.DefinitionStorage.push_back(std::move(Definition));
        RegisterStandaloneAsset(SyntheticPath,Raw);
        return Raw;
    }

    inline bool Resolve(const VFJson::Value& Root, FStandaloneOwnerWorld& Out, std::string& Error)
    {
        if (Root.Get("voxel_size_cm").Number() != VOXEL_SIZE)
        {
            Error = "export voxel_size_cm does not match the standalone VOXEL_SIZE";
            return false;
        }
        Out.Seed = static_cast<int32>(Root.Get("seed").Integer());
        Out.ClipRadius = static_cast<int32>(Root.Get("clip_radius").Integer(6));
        Out.MaxClipLevel = static_cast<int32>(Root.Get("max_clip_level").Integer(8));
        Out.FullResClipLevels = static_cast<int32>(Root.Get("full_res_clip_levels").Integer(2));
        Out.CoarseTileCells = static_cast<int32>(Root.Get("coarse_tile_cells").Integer(16));
        Out.RenderDistanceChunks = static_cast<int32>(Root.Get("render_distance_chunks").Integer(1536));
        Out.StrateContentCutMinLevel = static_cast<int32>(Root.Get("strate_content_cut_min_level").Integer(9));
        Out.bGenerateSkirts = Root.Get("generate_skirts").Boolean(true);
        Out.SkirtCells = static_cast<int32>(Root.Get("skirt_cells").Integer(2));
        Out.LODOctaveDrop = static_cast<int32>(Root.Get("lod_octave_drop").Integer(0));
        ReadVector(Root.Get("viewer_start"),Out.ViewerStartVoxels);
        Out.ViewerStartFound = Root.Get("viewer_start").Get("found_open_space").Boolean();
        for (const VFJson::Value& SampleJson : Root.Get("density_samples").AsArray())
        {
            FStandaloneParitySample Sample;
            ReadField(SampleJson,"x",Sample.PositionVoxels.X);
            ReadField(SampleJson,"y",Sample.PositionVoxels.Y);
            ReadField(SampleJson,"z",Sample.PositionVoxels.Z);
            ReadField(SampleJson,"density",Sample.PluginDensity);
            ReadField(SampleJson,"strate_index",Sample.StrateIndex);
            Sample.Kind = SampleJson.Get("kind").String();
            Out.DensitySamples.push_back(std::move(Sample));
        }

        Out.Settings = std::make_unique<UVoxelSettings>();
        const VFJson::Value& SettingsJson = Root.Get("settings_asset");
        Out.Settings->Seed = Out.Seed;
        ReadField(Root,"origin_spine_radius",Out.Settings->OriginSpineRadius);
        ReadField(Root,"world_radius_voxels",Out.Settings->WorldRadiusVoxels);
        ReadField(Root,"edge_seal_thickness",Out.Settings->EdgeSealThickness);
        ReadField(Root,"open_surface_entry",Out.Settings->bOpenSurfaceEntry);
        ReadField(Root,"inter_strate_gap_chunks",Out.Settings->InterStrateGapChunks);
        ReadField(SettingsJson,"total_strates",Out.Settings->TotalStrates);
        ReadField(Root,"clip_radius",Out.Settings->ClipRadius);
        ReadField(Root,"max_clip_level",Out.Settings->MaxClipLevel);
        ReadField(Root,"full_res_clip_levels",Out.Settings->FullResClipLevels);
        ReadField(Root,"coarse_tile_cells",Out.Settings->CoarseTileCells);
        ReadField(Root,"render_distance_chunks",Out.Settings->RenderDistanceChunks);
        ReadField(Root,"generate_skirts",Out.Settings->bGenerateSkirts);
        ReadField(Root,"skirt_cells",Out.Settings->SkirtCells);
        ReadField(Root,"lod_octave_drop",Out.Settings->LODOctaveDrop);
        ReadField(Root,"strate_content_cut_min_level",Out.Settings->StrateContentCutMinLevel);
        ReadField(SettingsJson,"TotalStrates",Out.Settings->TotalStrates);
        ReadField(SettingsJson,"InterStrateGapChunks",Out.Settings->InterStrateGapChunks);
        Out.Settings->StratePool.Reset();
        Out.Settings->FixedStrates.Empty();
        const auto& Strates = Root.Get("strates").AsArray();
        Out.Settings->TotalStrates = static_cast<int32>(Strates.size());
        for (int32 I = 0; I < static_cast<int32>(Strates.size()); ++I)
        {
            UVoxelStrateDefinition* Definition = ReadDefinition(Out,Strates[static_cast<size_t>(I)],I);
            const FString SyntheticPath = FString::Printf("/Standalone/Strate_%d",I);
            TSoftObjectPtr<UVoxelStrateDefinition> SoftDefinition;
            SoftDefinition.Set(Definition,SyntheticPath);
            Out.Settings->FixedStrates.Add(I,std::move(SoftDefinition));
        }
        if (Strates.empty()) { Error = "owner JSON contains no resolved strates"; return false; }

        Out.Manager = std::make_unique<UVoxelStrateManager>();
        if (!Out.Manager->Initialize(Out.Settings.get(),Out.Seed))
        {
            Error = "copied strate manager rejected the owner settings snapshot";
            return false;
        }
        Out.Generator = std::make_unique<UVoxelGenerator>();
        Out.Generator->InitializeSettings(Out.Settings.get());
        Out.Generator->SetStrateManager(Out.Manager.get());
        return true;
    }

    inline bool LoadJson(std::string_view Json,FStandaloneOwnerWorld& Out,std::string& Error)
    {
        VFJson::Value Root;
        if(!VFJson::Parser(std::string(Json)).Parse(Root,Error))return false;
        return Resolve(Root,Out,Error);
    }

    inline bool Load(const std::string& Path,FStandaloneOwnerWorld& Out,std::string& Error)
    {
        VFJson::Value Root;
        if(!VFJson::Load(Path,Root,Error))return false;
        return Resolve(Root,Out,Error);
    }
}