using System;
using System.Collections.Generic;
using AwesomeTechnologies.Utility;
using AwesomeTechnologies.Utility.Quadtree;
using AwesomeTechnologies.Vegetation;
using AwesomeTechnologies.VegetationStudio;
using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Serialization;

namespace AwesomeTechnologies.VegetationSystem
{
    [BurstCompile(CompileSynchronously = true)]
    public struct UnityTerrainSampleConcaveJob : IJobParallelForDefer
    {
        [NativeDisableParallelForRestriction]
        public NativeList<byte> Excluded;
        [NativeDisableParallelForRestriction]
        public NativeList<float3> Position;
        [ReadOnly] public NativeArray<float> InputHeights;

        public float Distance;
        public float MinHeightDifference;
        public bool Inverse;
        public bool Average;

        public int HeightmapWidth;
        public int HeightmapHeight;
        public Vector3 HeightMapScale;
        public Vector3 Size;
        public Vector3 TerrainPosition;

        public void Execute(int index)
        {
            if (Excluded[index] == 1) return;

            Vector3 worldPosition = Position[index];
            Vector3 terrainSpacePositon = worldPosition - TerrainPosition;
            float2 heightmapPosition = new float2(terrainSpacePositon.x / HeightMapScale.x,
                terrainSpacePositon.z / HeightMapScale.z);

            int x = Mathf.RoundToInt(heightmapPosition.x);
            int z = Mathf.RoundToInt(heightmapPosition.y);

            int sampleDistance = Mathf.RoundToInt(Distance / HeightMapScale.x);
            float centerHeight = GetHeight(x, z);

            float height1 = GetHeight(x - sampleDistance, z - sampleDistance);
            float height2 = GetHeight(x, z - sampleDistance);
            float height3 = GetHeight(x + sampleDistance, z - sampleDistance);

            float height4 = GetHeight(x - sampleDistance, z);
            float height5 = GetHeight(x + sampleDistance, z);

            float height6 = GetHeight(x - sampleDistance, z + sampleDistance);
            float height7 = GetHeight(x, z + sampleDistance);
            float height8 = GetHeight(x + sampleDistance, z + sampleDistance);

            float edgeHeight;

            if (Average)
            {
                edgeHeight = (height1 + height2 + height3 + height4 + height5 + height6 + height7 + height8) / 8f;
            }
            else
            {
                edgeHeight = GetMinimumHeight(height1, height2, height3, height4, height5, height6, height7, height8);
            }

            bool remove = edgeHeight < centerHeight + MinHeightDifference;
            if (Inverse) remove = !remove;
            if (!remove) return;

            Excluded[index] = 1;
        }

        float GetMinimumHeight(float height1, float height2, float height3, float height4, float height5, float height6,
            float height7, float height8)
        {
            float minHeight = math.min(height1, height2);
            minHeight = math.min(minHeight, height3);
            minHeight = math.min(minHeight, height4);
            minHeight = math.min(minHeight, height5);
            minHeight = math.min(minHeight, height6);
            minHeight = math.min(minHeight, height7);
            minHeight = math.min(minHeight, height8);
            return minHeight;
        }

        float GetHeight(int x, int y)
        {
            x = math.clamp(x, 0, HeightmapWidth - 1);
            y = math.clamp(y, 0, HeightmapHeight - 1);
            return InputHeights[y * HeightmapWidth + x] * HeightMapScale.y;
        }
    }

    [BurstCompile(CompileSynchronously = true)]
    public struct UnityTerranCellSampleJob : IJobParallelFor
    {
        [ReadOnly] public NativeArray<float> InputHeights;
        public NativeArray<Bounds> VegetationCellBoundsList;
        public int HeightmapWidth;

        public int HeightmapHeight;

        //public Vector3 Scale;
        public Vector3 HeightMapScale;

        public Rect TerrainRect;
        public Vector3 TerrainPosition;
        public float WorldspaceHeightCutoff;


        public void Execute(int index)
        {
            Bounds vegetationCellBounds = VegetationCellBoundsList[index];
            Rect cellRect = RectExtension.CreateRectFromBounds(vegetationCellBounds);
            if (!TerrainRect.Overlaps(cellRect)) return;

            float2 worldspaceCellCorner = new float2(vegetationCellBounds.center.x - vegetationCellBounds.extents.x,
                vegetationCellBounds.center.z - vegetationCellBounds.extents.z);
            float2 terrainspaceCellCorner = new float2(worldspaceCellCorner.x - TerrainPosition.x,
                worldspaceCellCorner.y - TerrainPosition.z);
            float2 heightmapPosition = new float2(terrainspaceCellCorner.x / HeightMapScale.x,
                terrainspaceCellCorner.y / HeightMapScale.z);

            int xCount = Mathf.CeilToInt(cellRect.width / HeightMapScale.x);
            int zCount = Mathf.CeilToInt(cellRect.height / HeightMapScale.z);

            int xStart = Mathf.FloorToInt(heightmapPosition.x);
            int zStart = Mathf.FloorToInt(heightmapPosition.y);

            float minHeight = float.MaxValue;
            float maxHeight = float.MinValue;
            for (int x = xStart; x <= xStart + xCount; x++)
            {
                for (int z = zStart; z <= zStart + zCount; z++)
                {
                    float heightSample = GetHeight(x, z);
                    if (heightSample < minHeight) minHeight = heightSample;
                    if (heightSample > maxHeight) maxHeight = heightSample;
                }
            }


            if (maxHeight + TerrainPosition.y < WorldspaceHeightCutoff) return;

            float centerY = (maxHeight + minHeight) / 2f;
            float height = maxHeight - minHeight;
            vegetationCellBounds =
                new Bounds(
                    new Vector3(vegetationCellBounds.center.x, centerY + TerrainPosition.y,
                        vegetationCellBounds.center.z),
                    new Vector3(vegetationCellBounds.size.x, height, vegetationCellBounds.size.z));
            VegetationCellBoundsList[index] = vegetationCellBounds;
        }

        float GetHeight(int x, int y)
        {
            x = math.clamp(x, 0, HeightmapWidth - 1);
            y = math.clamp(y, 0, HeightmapHeight - 1);
            return InputHeights[y * HeightmapWidth + x] * HeightMapScale.y;
        }
    }

//    [BurstCompile(CompileSynchronously = true)]
//    public struct UnityTerrainSampleJob : IJobParallelFor
//    {
//        [ReadOnly] public NativeArray<float> InputHeights;
//        [ReadOnly] public NativeArray<VegetationSpawnLocationInstance> SpawnLocationList;
//        public NativeArray<VegetationInstance> InstanceList;
//        public int HeightmapWidth;
//        public int HeightmapHeight;
//        public Vector3 Scale;
//        public Vector3 Size;
//        public Vector3 HeightMapScale;
//        public Vector3 TerrainPosition;
//        public byte TerrainSourceID;
//
//        public void Execute(int index)
//        {
//            VegetationInstance vegetationInstance = InstanceList[index];
//            if (vegetationInstance.HeightmapSampled == 1) return;     
//
//            VegetationSpawnLocationInstance spawnLocation = SpawnLocationList[index];
//            
//            if (spawnLocation.SpawnChance < 0)
//            {
//                vegetationInstance.Excluded = 1;
//                vegetationInstance.HeightmapSampled = 1;
//                InstanceList[index] = vegetationInstance;
//                return;
//            }
//
//            Vector3 worldPosition = spawnLocation.Position;
//            Vector3 terrainSpacePositon = worldPosition - TerrainPosition;
//            float2 interpolatedPosition = new float2(terrainSpacePositon.x / Size.x, terrainSpacePositon.z / Size.z);
//
//            if (interpolatedPosition.x < 0 || interpolatedPosition.x > 1 || interpolatedPosition.y < 0 ||
//                interpolatedPosition.y > 1)
//            {
//                {
//                    vegetationInstance.Excluded = 1;
//                    InstanceList[index] = vegetationInstance;
//                    return;
//                }
//            }
//
//            float height = GetTriangleInterpolatedHeight(interpolatedPosition.x, interpolatedPosition.y);
//            vegetationInstance.Position = new float3(spawnLocation.Position.x, height + TerrainPosition.y,
//                spawnLocation.Position.z);
//            vegetationInstance.TerrainNormal =
//                GetInterpolatedNormal(interpolatedPosition.x, interpolatedPosition.y);
//            vegetationInstance.Scale = new float3(1, 1, 1);
//            vegetationInstance.Rotation = Quaternion.Euler(0, 0, 0);
//            vegetationInstance.RandomNumberIndex = spawnLocation.RandomNumberIndex;
//            vegetationInstance.BiomeDistance = spawnLocation.BiomeDistance;
//            vegetationInstance.DistanceFalloff = 1;
//            vegetationInstance.TerrainSourceID = TerrainSourceID;
//            vegetationInstance.Excluded = 0;
//            vegetationInstance.HeightmapSampled = 1;
//            InstanceList[index] = vegetationInstance;
//        }
//
//        float GetTriangleInterpolatedHeight(float x, float y)
//        {
//            float fx = x * (HeightmapWidth - 1);
//            float fy = y * (HeightmapHeight - 1);
//            int lx = (int) fx;
//            int ly = (int) fy;
//
//            float u = fx - lx;
//            float v = fy - ly;
//            if (u > v)
//            {
//                float z00 = GetHeight(lx + 0, ly + 0);
//                float z01 = GetHeight(lx + 1, ly + 0);
//                float z11 = GetHeight(lx + 1, ly + 1);
//                return z00 + (z01 - z00) * u + (z11 - z01) * v;
//            }
//            else
//            {
//                float z00 = GetHeight(lx + 0, ly + 0);
//                float z10 = GetHeight(lx + 0, ly + 1);
//                float z11 = GetHeight(lx + 1, ly + 1);
//                return z00 + (z11 - z10) * u + (z10 - z00) * v;
//            }
//        }
//
//        float GetHeight(int x, int y)
//        {
//            x = math.clamp(x, 0, HeightmapWidth - 1);
//            y = math.clamp(y, 0, HeightmapHeight - 1);
//            return InputHeights[y * HeightmapWidth + x] * HeightMapScale.y;
//        }
//
//        public float3 GetInterpolatedNormal(float x, float y)
//        {
//            float fx = x * (HeightmapWidth - 1);
//            float fy = y * (HeightmapHeight - 1);
//            int lx = (int) fx;
//            int ly = (int) fy;
//
//            float3 n00 = CalculateNormalSobel(lx + 0, ly + 0);
//            float3 n10 = CalculateNormalSobel(lx + 1, ly + 0);
//            float3 n01 = CalculateNormalSobel(lx + 0, ly + 1);
//            float3 n11 = CalculateNormalSobel(lx + 1, ly + 1);
//
//            float u = fx - lx;
//            float v = fy - ly;
//
//            float3 s = math.lerp(n00, n10, u);
//            float3 t = math.lerp(n01, n11, u);
//            float3 value = math.lerp(s, t, v);
//            return math.normalize(value);
//        }
//
//        float3 CalculateNormalSobel(int x, int y)
//        {
//            float3 normal;
//            var dX = GetHeight(x - 1, y - 1) * -1.0F;
//            dX += GetHeight(x - 1, y) * -2.0F;
//            dX += GetHeight(x - 1, y + 1) * -1.0F;
//            dX += GetHeight(x + 1, y - 1) * 1.0F;
//            dX += GetHeight(x + 1, y) * 2.0F;
//            dX += GetHeight(x + 1, y + 1) * 1.0F;
//
//            dX /= Scale.x;
//
//            var dY = GetHeight(x - 1, y - 1) * -1.0F;
//            dY += GetHeight(x, y - 1) * -2.0F;
//            dY += GetHeight(x + 1, y - 1) * -1.0F;
//            dY += GetHeight(x - 1, y + 1) * 1.0F;
//            dY += GetHeight(x, y + 1) * 2.0F;
//            dY += GetHeight(x + 1, y + 1) * 1.0F;
//            dY /= Scale.z;
//
//            normal.x = -dX;
//            normal.y = 8;
//            normal.z = -dY;
//            return math.normalize(normal);
//        }
//    }
    
    [BurstCompile(CompileSynchronously = true)]
    public struct UnityTerrainSampleJob : IJobParallelFor
    {
        [ReadOnly] public NativeArray<float> InputHeights;
        [ReadOnly] public NativeArray<VegetationSpawnLocationInstance> SpawnLocationList;
        //public NativeArray<VegetationInstance> InstanceList;
        
        public NativeArray<float3> Position;
        public NativeArray<quaternion> Rotation;
        public NativeArray<float3> Scales;
        public NativeArray<float3> TerrainNormal;
        public NativeArray<float> BiomeDistance;
        public NativeArray<byte> TerrainTextureData;
        public NativeArray<int> RandomNumberIndex;
        public NativeArray<float> DistanceFalloff;
        public NativeArray<float> VegetationMaskDensity;
        public NativeArray<float> VegetationMaskScale;
        public NativeArray<byte> TerrainSourceIDs;        
        public NativeArray<byte> TextureMaskData;
        public NativeArray<byte> Excluded;
        public NativeArray<byte> HeightmapSampled;
        
        public int HeightmapWidth;
        public int HeightmapHeight;
        public Vector3 Scale;
        public Vector3 Size;
        public Vector3 HeightMapScale;
        public Vector3 TerrainPosition;
        public byte TerrainSourceID;

        public void Execute(int index)
        {
            if (HeightmapSampled[index] == 1) return;     

            VegetationSpawnLocationInstance spawnLocation = SpawnLocationList[index];
            
            if (spawnLocation.SpawnChance < 0)
            {
                Excluded[index] = 1;
                HeightmapSampled[index] = 1;
                return;
            }

            Vector3 worldPosition = spawnLocation.Position;
            Vector3 terrainSpacePositon = worldPosition - TerrainPosition;
            float2 interpolatedPosition = new float2(terrainSpacePositon.x / Size.x, terrainSpacePositon.z / Size.z);

            if (interpolatedPosition.x < 0 || interpolatedPosition.x > 1 || interpolatedPosition.y < 0 ||
                interpolatedPosition.y > 1)
            {
                {
                    Excluded[index] = 1;
                    return;
                }
            }

            float height = GetTriangleInterpolatedHeight(interpolatedPosition.x, interpolatedPosition.y);
            
            
            Position[index] = new float3(spawnLocation.Position.x, height + TerrainPosition.y,spawnLocation.Position.z);
            TerrainNormal[index] = GetInterpolatedNormal(interpolatedPosition.x, interpolatedPosition.y);
            Scales[index] = new float3(1, 1, 1);
            Rotation[index] = Quaternion.Euler(0, 0, 0);
            RandomNumberIndex[index] = spawnLocation.RandomNumberIndex;
            BiomeDistance[index] = spawnLocation.BiomeDistance;
            DistanceFalloff[index] = 1;
            TerrainSourceIDs[index] = TerrainSourceID;
            Excluded[index] = 0;
            HeightmapSampled[index] = 1;            
            TerrainTextureData[index] = 0;
            //TODO make sure we do not need to init these 2 here
            VegetationMaskDensity[index] = 0;
            VegetationMaskScale[index] = 0;
            TextureMaskData[index] = 0;    
        }

        float GetTriangleInterpolatedHeight(float x, float y)
        {
            float fx = x * (HeightmapWidth - 1);
            float fy = y * (HeightmapHeight - 1);
            int lx = (int) fx;
            int ly = (int) fy;

            float u = fx - lx;
            float v = fy - ly;
            if (u > v)
            {
                float z00 = GetHeight(lx + 0, ly + 0);
                float z01 = GetHeight(lx + 1, ly + 0);
                float z11 = GetHeight(lx + 1, ly + 1);
                return z00 + (z01 - z00) * u + (z11 - z01) * v;
            }
            else
            {
                float z00 = GetHeight(lx + 0, ly + 0);
                float z10 = GetHeight(lx + 0, ly + 1);
                float z11 = GetHeight(lx + 1, ly + 1);
                return z00 + (z11 - z10) * u + (z10 - z00) * v;
            }
        }

        float GetHeight(int x, int y)
        {
            x = math.clamp(x, 0, HeightmapWidth - 1);
            y = math.clamp(y, 0, HeightmapHeight - 1);
            return InputHeights[y * HeightmapWidth + x] * HeightMapScale.y;
        }

        public float3 GetInterpolatedNormal(float x, float y)
        {
            float fx = x * (HeightmapWidth - 1);
            float fy = y * (HeightmapHeight - 1);
            int lx = (int) fx;
            int ly = (int) fy;

            float3 n00 = CalculateNormalSobel(lx + 0, ly + 0);
            float3 n10 = CalculateNormalSobel(lx + 1, ly + 0);
            float3 n01 = CalculateNormalSobel(lx + 0, ly + 1);
            float3 n11 = CalculateNormalSobel(lx + 1, ly + 1);

            float u = fx - lx;
            float v = fy - ly;

            float3 s = math.lerp(n00, n10, u);
            float3 t = math.lerp(n01, n11, u);
            float3 value = math.lerp(s, t, v);
            return math.normalize(value);
        }

        float3 CalculateNormalSobel(int x, int y)
        {
            float3 normal;
            var dX = GetHeight(x - 1, y - 1) * -1.0F;
            dX += GetHeight(x - 1, y) * -2.0F;
            dX += GetHeight(x - 1, y + 1) * -1.0F;
            dX += GetHeight(x + 1, y - 1) * 1.0F;
            dX += GetHeight(x + 1, y) * 2.0F;
            dX += GetHeight(x + 1, y + 1) * 1.0F;

            dX /= Scale.x;

            var dY = GetHeight(x - 1, y - 1) * -1.0F;
            dY += GetHeight(x, y - 1) * -2.0F;
            dY += GetHeight(x + 1, y - 1) * -1.0F;
            dY += GetHeight(x - 1, y + 1) * 1.0F;
            dY += GetHeight(x, y + 1) * 2.0F;
            dY += GetHeight(x + 1, y + 1) * 1.0F;
            dY /= Scale.z;

            normal.x = -dX;
            normal.y = 8;
            normal.z = -dY;
            return math.normalize(normal);
        }
    }
    
    [BurstCompile]
    public struct AddToInstanceListJob : IJob
    {
        [DeallocateOnJobCompletion] public NativeArray<VegetationInstance> SourceInstanceArray;
        public NativeList<VegetationInstance> TargetInstanceList;

        public void Execute()
        {
            for (int i = 0; i <= SourceInstanceArray.Length - 1; i++)
            {
                VegetationInstance vegetationInstance = SourceInstanceArray[i];
                if (vegetationInstance.Excluded == 1) continue;
                TargetInstanceList.Add(vegetationInstance);
            }
        }
    }

    [AwesomeTechnologiesScriptOrder(-100)]
    [ExecuteInEditMode]
    public partial class UnityTerrain : MonoBehaviour, IVegetationStudioTerrain
    {
        public NativeArray<float> Heights;
        [FormerlySerializedAs("_terrain")] public Terrain Terrain;

        private int _heightmapHeight;
        private int _heightmapWidth;
        private Vector3 _size;
        private Vector3 _scale;
        private Vector3 _heightmapScale;

        private Rect _terrainRect;

        private readonly List<NativeArray<ARGBBytes>> _splatMapArrayList = new List<NativeArray<ARGBBytes>>();
        private readonly List<int> _splatMapFormatList = new List<int>();

#if !UNITY_2019_2_OR_NEWER    
        private Terrain.MaterialType _originalTerrainMaterialType = Terrain.MaterialType.BuiltInStandard;
#endif        
        private Material _originalTerrainMaterial;
        private float _originalTerrainheightmapPixelError;
        public bool TerrainMaterialOverridden;
        private bool _originalTerrainInstanced;
        private float _originalBasemapDistance;
        [NonSerialized] public Material TerrainHeatmapMaterial;

        public bool DisableTerrainTreesAndDetails = true;

        public bool AutoAddToVegegetationSystem;

        private bool _initDone;
        public TerrainSourceID TerrainSourceID;

        public Vector3 TerrainPosition = Vector3.zero;

        // ReSharper disable once UnusedMember.Local
        void Reset()
        {
            FindTerrain();

            TerrainPosition = transform.position;
        }

        void FindTerrain()
        {
            if (!Terrain)
            {
                Terrain = gameObject.GetComponent<Terrain>();
            }
        }

        // ReSharper disable once UnusedMember.Local
        void Awake()
        {
            FindTerrain();
        }

        void Start()
        {
            if (Terrain && DisableTerrainTreesAndDetails)
            {
                Terrain.drawTreesAndFoliage = false;
            }
        }

        //private ManagedNativeFloatArray _nativeManagedFloatArray;

        void LoadHeightData()
        {
            var terrainData = Terrain.terrainData;
            _heightmapScale = terrainData.heightmapScale;
            _heightmapHeight = terrainData.heightmapResolution;
            _heightmapWidth = terrainData.heightmapResolution;

            _size = terrainData.size;
            _scale.x = _size.x / (_heightmapWidth - 1);
            _scale.y = _size.y;
            _scale.z = _size.z / (_heightmapHeight - 1);

            Vector2 terrainCenter = new Vector2(TerrainPosition.x, TerrainPosition.z);
            Vector2 terrainSize = new Vector2(_size.x, _size.z);
            _terrainRect = new Rect(terrainCenter, terrainSize);

            float[,] hs = Terrain.terrainData.GetHeights(0, 0, _heightmapWidth, _heightmapHeight);

            if (Heights.IsCreated) Heights.Dispose();

            Heights = new NativeArray<float>(_heightmapWidth * _heightmapHeight, Allocator.Persistent);
            Heights.CopyFromFast(hs);
        }

        public JobHandle SampleTerrain(NativeList<VegetationSpawnLocationInstance> spawnLocationList,
            VegetationInstanceData  instanceData, int sampleCount, Rect spawnRect, JobHandle dependsOn)
        {
            if (!_initDone) return dependsOn;
            
            
            if (spawnRect.Overlaps(_terrainRect))
            {
                UnityTerrainSampleJob unityTerrainSampleJob = new UnityTerrainSampleJob
                {
                    InputHeights = Heights,
                    
                    SpawnLocationList = spawnLocationList,
                    Position = instanceData.Position,
                    Rotation = instanceData.Rotation,
                    Scales = instanceData.Scale,
                    TerrainNormal= instanceData.TerrainNormal,
                    BiomeDistance= instanceData.BiomeDistance,
                    TerrainTextureData= instanceData.TerrainTextureData,
                    RandomNumberIndex= instanceData.RandomNumberIndex,
                    DistanceFalloff= instanceData.DistanceFalloff,
                    VegetationMaskDensity= instanceData.VegetationMaskDensity,
                    VegetationMaskScale= instanceData.VegetationMaskScale,
                    TerrainSourceIDs= instanceData.TerrainSourceID,
                    TextureMaskData= instanceData.TextureMaskData,
                    Excluded= instanceData.Excluded,
                    HeightmapSampled= instanceData.HeightmapSampled,  

                    

                    HeightMapScale = _heightmapScale,
                    HeightmapHeight = _heightmapHeight,
                    HeightmapWidth = _heightmapWidth,
                    TerrainPosition = TerrainPosition,
                    Scale = _scale,
                    Size = _size,
                    TerrainSourceID = (byte) TerrainSourceID
                };
                JobHandle handle = unityTerrainSampleJob.Schedule(sampleCount,64,dependsOn);
                return handle;
            }
            return dependsOn;
        }

        public void RefreshTerrainData()
        {
            LoadHeightData();
        }

        public void RefreshTerrainData(Bounds bounds)
        {
            Rect terrainRect = RectExtension.CreateRectFromBounds(TerrainBounds);
            Rect updateRect = RectExtension.CreateRectFromBounds(bounds);
            if (!updateRect.Overlaps(terrainRect))
            {
                LoadHeightData();
            }
        }

        public JobHandle SampleCellHeight(NativeArray<Bounds> vegetationCellBoundsList, float worldspaceHeightCutoff,
            Rect cellBoundsRect, JobHandle dependsOn = default(JobHandle))
        {
            if (!_initDone) return dependsOn;
            if (!Heights.IsCreated) LoadHeightData();

            if (cellBoundsRect.Overlaps(_terrainRect))
            {
                UnityTerranCellSampleJob unityTerranCellSampleJob = new UnityTerranCellSampleJob
                {
                    InputHeights = Heights,
                    VegetationCellBoundsList = vegetationCellBoundsList,
                    HeightMapScale = _heightmapScale,
                    HeightmapHeight = _heightmapHeight,
                    HeightmapWidth = _heightmapWidth,
                    TerrainPosition = TerrainPosition,
                    WorldspaceHeightCutoff = worldspaceHeightCutoff,
                    TerrainRect = RectExtension.CreateRectFromBounds(TerrainBounds)
                };

                JobHandle handle = unityTerranCellSampleJob.Schedule(vegetationCellBoundsList.Length, 32, dependsOn);
                return handle;
            }

            return dependsOn;
        }

        public JobHandle SampleConcaveLocation(VegetationInstanceData instanceData, float minHeightDifference,
            float distance, bool inverse, bool average, Rect spawnRect,
            JobHandle dependsOn)
        {
            if (!_initDone) return dependsOn;

            if (spawnRect.Overlaps(_terrainRect))
            {
                UnityTerrainSampleConcaveJob unityTerrainSampleConcaveLocationJob = new UnityTerrainSampleConcaveJob
                {
                    InputHeights = Heights,
                    
                    Excluded  = instanceData.Excluded,
                    Position = instanceData.Position,

                    HeightMapScale = _heightmapScale,
                    HeightmapHeight = _heightmapHeight,
                    HeightmapWidth = _heightmapWidth,
                    TerrainPosition = TerrainPosition,
                    Size = _size,
                    Distance = distance,
                    MinHeightDifference = minHeightDifference,
                    Inverse = inverse,
                    Average = average
                };

                JobHandle handle = unityTerrainSampleConcaveLocationJob.Schedule(instanceData.Excluded, 64, dependsOn);
                return handle;
            }

            return dependsOn;
        }

        public void Init()
        {
            if (!Heights.IsCreated) LoadHeightData();
            //if (_nativeManagedFloatArray == null) LoadHeightData();
        }

        public void DisposeTemporaryMemory()
        {
        }

        public bool HasTerrainTextures()
        {
            return true;
        }

        public Texture2D GetTerrainTexture(int index)
        {
            if (!Terrain) return null;
            if (!Terrain.terrainData) return null;

#if UNITY_2018_3_OR_NEWER
            if (Terrain.terrainData.terrainLayers.Length > index)
            {
                if (Terrain.terrainData.terrainLayers[index])
                {
                    return Terrain.terrainData.terrainLayers[index].diffuseTexture;
                }
                else
                {
                    return null;
                }               
            }
 
#else
            if (Terrain.terrainData.splatPrototypes.Length > index)
            {
                return Terrain.terrainData.splatPrototypes[index].texture;
            }
#endif

            return null;
        }

#if UNITY_2018_3_OR_NEWER
        public TerrainLayer[] GetTerrainLayers()
        {
            if (!Terrain) return new TerrainLayer[0];
            return Terrain.terrainData.terrainLayers;
        }

        public void SetTerrainLayers(TerrainLayer[] terrainLayers)
        {
            if (Terrain)
            {                            
                Terrain.terrainData.terrainLayers = terrainLayers;
            }
        }
     
#else
        public SplatPrototype[] GetSplatPrototypes()
        {
            if (!Terrain) return new SplatPrototype[0];
            return Terrain.terrainData.splatPrototypes;
        }

        public void SetSplatPrototypes(SplatPrototype[] splatPrototypes)
        {
            if (Terrain)
            {
                Terrain.terrainData.splatPrototypes = splatPrototypes;
            }
        }
#endif

        //// ReSharper disable once UnusedMember.Local
        void OnEnable()
        {
            RefreshSplatMaps();

            _initDone = true;

            if (AutoAddToVegegetationSystem && Application.isPlaying)
            {
                AddTerrainToVegetationSystem();
            }
            else
            {
                VegetationStudioManager.RefreshTerrainArea(TerrainBounds);
            }
        }

        public void AddTerrainToVegetationSystem()
        {
            VegetationStudioManager.AddTerrain(gameObject, false);
        }

        // ReSharper disable once UnusedMember.Local
        void OnDisable()
        {
            _initDone = false;

            if (AutoAddToVegegetationSystem && Application.isPlaying)
            {
                VegetationStudioManager.RemoveTerrain(gameObject);
            }
            else
            {
                VegetationStudioManager.RefreshTerrainArea(TerrainBounds);
            }

            Dispose();
        }

        public void RefreshTerrainArea()
        {
            VegetationStudioManager.RefreshTerrainArea(TerrainBounds);
        }

        public void Dispose()
        {
            //_nativeManagedFloatArray?.Dispose();
            if (Heights.IsCreated)
            {
                Heights.Dispose();
            }

        }

        public string TerrainType => "Unity terrain";

        public Bounds TerrainBounds
        {
            get
            {
                if (Terrain)
                {
                    var terrainData = Terrain.terrainData;
                    return new Bounds(terrainData.bounds.center + TerrainPosition,
                        terrainData.bounds.size);
                }

                return new Bounds(Vector3.zero, Vector3.zero);
            }
        }

        // ReSharper disable once UnusedMember.Local
        void OnDrawGizmosSelected()
        {
            Gizmos.color = Color.blue;
            Gizmos.DrawWireCube(TerrainBounds.center, TerrainBounds.size);
        }

        void Update()
        {
            if (!Application.isPlaying)
            {
                TerrainPosition = transform.position;
            }
        }
    }
}