using System.Collections.Generic;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;

public struct TerrainGenJob : IJob
{
    public Vector2 InitialCrawlPosition { get; private set; }
    public Vector2Int GridPosition { get; private set; }
    private List<Octave> octaves;
    public int Samples { get; private set; }
    public TerrainData TerrainData { get; private set; }
    private float[,] heights;
    private bool ready;

    public List<float> crawlPositionsX;
    public List<float> crawlPositionsY;

    public TerrainGenJob(Vector2 initialCrawlPos, Vector2Int gridPos, List<Octave> octaves, int samples, TerrainData data)
    {
        crawlPositionsX = new();
        crawlPositionsY = new();

        heights = null;
        ready = false;

        InitialCrawlPosition = initialCrawlPos;
        GridPosition = gridPos;
        Samples = samples;
        this.octaves = octaves;
        TerrainData = data;
    }

    public float[,] GetHeights()
    {
        if (ready)
            return heights;
        else
            throw new System.InvalidOperationException("Heights not built yet.");
    }

    public void Generate()
    {
        heights = new float[Samples, Samples];

        foreach (var octave in octaves)
        {
            for (int x = 0; x < Samples; x++)
            {
                for (int y = 0; y < Samples; y++)
                {
                    float2 crawlPos = new((x + InitialCrawlPosition.x * (Samples - 1)) * octave.frequency,
                        (y + InitialCrawlPosition.y * (Samples - 1)) * octave.frequency);
                    crawlPositionsX.Add(crawlPos.x);
                    crawlPositionsY.Add(crawlPos.y);
                    
                    float addition;

                    switch (octave.type)
                    {
                        default:
                        case NoiseType.MathfPerlin:
                            addition = Mathf.PerlinNoise(crawlPos.x, crawlPos.y);
                            break;
                        case NoiseType.MathematicsPerlin:
                            addition = noise.cnoise(crawlPos) / 2.3f + 0.5f;
                            break;
                        case NoiseType.Simplex:
                            addition = noise.snoise(crawlPos) / 4.6f + 0.5f;
                            break;
                        case NoiseType.Celluar:
                            addition = noise.cellular(crawlPos).x / 2.3f + 0.5f;
                            break;
                    }
                    heights[y, x] += addition * octave.amplitude;
                }
            }
        }

        ready = true;
    }

    public void Execute()
    {
        Generate();
    }
}