--luacheck:ignore
local simplex_noise = require 'utils.tools.simplex_noise'
local Event = require 'utils.event'
biter_battles_terrain = {}

--no need to constantly work out each chunk
local radius = 24 --starting pond radius
local radsquare = radius * radius
local ore_amount = 1400
local ores = { 'copper-ore', 'iron-ore', 'stone', 'coal', 'uranium-ore' }

-- /c game.forces["north"].chart(game.player.surface, {lefttop = {x = -1024, y = -1024}, rightbottom = {x = 1024, y = 1024}})

local function on_chunk_generated(event)
    if not storage.noise_seed then
        storage.noise_seed = math.random(1, 5000000)
    end
    local left_top = event.area.left_top --decreased var calls in later loop with more direct
    local surface = game.surfaces[1]
    local noise = {}

    local entities = surface.find_entities(event.area)
    for _, entity in pairs(entities) do
        if entity.type == 'resource' then
            entity.destroy()
        end
    end

    for x = 0, 31, 1 do
        for y = 0, 31, 1 do
            local pos_x = left_top.x + x
            local pos_y = left_top.y + y
            local tile_to_insert = false
            --noise[1] = simplex_noise.d2(pos_x/350, pos_y/350,storage.noise_seed)
            noise[1] = simplex_noise.d2(pos_x * 0.008, pos_y * 0.008, storage.noise_seed) --100
            noise[2] = simplex_noise.d2(pos_x * 0.05, pos_y * 0.05, storage.noise_seed + 10000)
            noise[3] = noise[1] + noise[2] * 0.1

            --local xx = 1
            --for yy = 1, 17, 1 do
            --local z = (yy % 4) + 1
            --xx = xx - 0.010
            --if noise[3] > xx then
            if noise[3] > 0.65 then
                --break
                local a = ore_amount * (1 + (noise[2] * 0.3)) --moved to when used
                --local z = (yy % 4) + 1
                noise[4] = simplex_noise.d2(pos_x * 0.005, pos_y * 0.005, storage.noise_seed + 5000)
                noise[5] = simplex_noise.d2(pos_x * 0.005, pos_y * 0.005, storage.noise_seed + 3000)
                local z = 2

                if noise[4] > 0.2 then
                    if noise[5] > 0.05 then
                        z = 3
                    elseif noise[5] < -0.05 then
                        z = 4
                    else
                        z = 5
                    end
                elseif noise[4] < -0.2 then
                    if noise[5] > 0.05 then
                        z = 1
                    elseif noise[5] < -0.05 then
                        z = 2
                    else
                        z = 5
                    end
                else
                    z = math.floor((noise[3] + noise[2] * 0.1) * 40) % 4 + 1
                end

                --if noise[4] > 0.0 and noise[4] < 0.05 then z = (math.floor((noise[3]+noise[2]*0.1)* 40) % 4) + 1 end
                if surface.can_place_entity { name = ores[z], position = { pos_x, pos_y }, amount = a } then
                    surface.create_entity { name = ores[z], position = { pos_x, pos_y }, amount = a }
                end
            elseif noise[3] < -0.85 then
                if math.random(1, 250) == 1 and surface.can_place_entity { name = 'crude-oil', position = { pos_x, pos_y } } then
                    surface.create_entity { name = 'crude-oil', position = { pos_x, pos_y }, amount = math.random(140000, 380000) }
                end
            end
            --end
        end
    end

    if left_top.y > 96 or left_top.y < -128 then
        return
    end --tweeked range
    local tiles = {}
    local spawn_tile = surface.get_tile(game.forces.south.get_spawn_position(surface))

    for x = 0, 31, 1 do
        for y = 0, 31, 1 do
            local pos_x = left_top.x + x
            local pos_y = left_top.y + y
            local tile_to_insert = false
            local tile_distance_to_center = pos_x ^ 2 + pos_y ^ 2
            noise[4] = simplex_noise.d2(pos_x * 0.0118, pos_y * 0.0118, storage.noise_seed + 20000)
            noise[5] = simplex_noise.d2(pos_x * 0.15, pos_y * 0.15, storage.noise_seed + 30000)
            noise[7] = 1 + (noise[4] + (noise[5] * 0.75)) * 0.1
            if pos_y >= ((storage.horizontal_border_width / 2) * -1) * noise[7] and pos_y <= (storage.horizontal_border_width / 2) * noise[7] then
                local entities = surface.find_entities({ { pos_x, pos_y }, { pos_x + 1, pos_y + 1 } })
                for _, e in pairs(entities) do
                    if e.type == 'simple-entity' or e.type == 'resource' or e.type == 'tree' then
                        e.destroy()
                    end
                end
                tile_to_insert = 'deepwater'
            else
                local t = surface.get_tile(pos_x, pos_y)
                if t.name == 'deepwater' or t.name == 'water' then
                    if tile_distance_to_center < 20000 then
                        if spawn_tile.name == 'water' or spawn_tile.name == 'deepwater' then
                            tile_to_insert = 'sand-1'
                        else
                            tile_to_insert = spawn_tile.name
                        end
                    end
                end
            end
            if tile_distance_to_center <= radsquare then
                if tile_distance_to_center >= radsquare / 10 then
                    tile_to_insert = 'deepwater'
                else
                    tile_to_insert = 'sand-1'
                    if tile_distance_to_center >= radsquare / 18 then
                        tile_to_insert = 'refined-concrete'
                    end
                end
            end
            if tile_to_insert then
                table.insert(tiles, { name = tile_to_insert, position = { pos_x, pos_y } })
            end
        end
    end
    surface.set_tiles(tiles, true)
    for x = 0, 31, 1 do
        for y = 0, 31, 1 do
            local pos_x = left_top.x + x
            local pos_y = left_top.y + y
            local t = surface.get_tile(pos_x, pos_y)
            if t.name == 'water' or t.name == 'deepwater' or t.name == 'water-green' then
                if surface.can_place_entity { name = 'fish', position = { pos_x, pos_y } } and math.random(1, 40) == 1 then
                    surface.create_entity { name = 'fish', position = { pos_x, pos_y } }
                end
            end
        end
    end
end

local function find_tile_placement_spot_around_target_position(tilename, position, mode, density)
    local x = position.x
    local y = position.y
    if not surface then
        surface = game.surfaces[1]
    end
    local scan_radius = 50
    if not tilename then
        return
    end
    if not mode then
        mode = 'ball'
    end
    if not density then
        density = 1
    end
    local cluster_tiles = {}
    local auto_correct = true

    local scanned_tile = surface.get_tile(x, y)
    if scanned_tile.name ~= tilename then
        table.insert(cluster_tiles, { name = tilename, position = { x, y } })
        surface.set_tiles(cluster_tiles, auto_correct)
        return true, x, y
    end

    local i = 2
    local r = 1

    if mode == 'ball' then
        if math.random(1, 2) == 1 then
            density = density * -1
        end
        r = math.random(1, 4)
    end
    if mode == 'line' then
        density = 1
        r = math.random(1, 4)
    end
    if mode == 'line_down' then
        density = density * -1
        r = math.random(1, 4)
    end
    if mode == 'line_up' then
        density = 1
        r = math.random(1, 4)
    end
    if mode == 'block' then
        r = 1
        density = 1
    end

    if r == 1 then
        --start placing at -1,-1
        while i <= scan_radius do
            y = y - density
            x = x - density
            for a = 1, i, 1 do
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
                x = x + density
            end
            for a = 1, i, 1 do
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
                y = y + density
            end
            for a = 1, i, 1 do
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
                x = x - density
            end
            for a = 1, i, 1 do
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
                y = y - density
            end
            i = i + 2
        end
    end

    if r == 2 then
        --start placing at 0,-1
        while i <= scan_radius do
            y = y - density
            x = x - density
            for a = 1, i, 1 do
                x = x + density
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
            end
            for a = 1, i, 1 do
                y = y + density
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
            end
            for a = 1, i, 1 do
                x = x - density
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
            end
            for a = 1, i, 1 do
                y = y - density
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
            end
            i = i + 2
        end
    end

    if r == 3 then
        --start placing at 1,-1
        while i <= scan_radius do
            y = y - density
            x = x + density
            for a = 1, i, 1 do
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
                y = y + density
            end
            for a = 1, i, 1 do
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
                x = x - density
            end
            for a = 1, i, 1 do
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
                y = y - density
            end
            for a = 1, i, 1 do
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
                x = x + density
            end
            i = i + 2
        end
    end

    if r == 4 then
        --start placing at 1,0
        while i <= scan_radius do
            y = y - density
            x = x + density
            for a = 1, i, 1 do
                y = y + density
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
            end
            for a = 1, i, 1 do
                x = x - density
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
            end
            for a = 1, i, 1 do
                y = y - density
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
            end
            for a = 1, i, 1 do
                x = x + density
                local scanned_tile = surface.get_tile(x, y)
                if scanned_tile.name ~= tilename then
                    table.insert(cluster_tiles, { name = tilename, position = { x, y } })
                    surface.set_tiles(cluster_tiles, auto_correct)
                    return true, x, y
                end
            end
            i = i + 2
        end
    end
    return false
end

local function create_tile_cluster(tilename, position, amount)
    local mode = 'ball'
    local cluster_tiles = {}
    local surface = game.surfaces[1]
    local pos = position
    local x = pos.x
    local y = pos.y
    for i = 1, amount, 1 do
        local b, x, y = find_tile_placement_spot_around_target_position(tilename, pos, mode)
        if b == true then
            if 1 == math.random(1, 16) then
                pos.x = x
                pos.y = y
            end
        end
        if b == false then
            return false, x, y
        end
        if i >= amount then
            return true, x, y
        end
    end
end

function biter_battles_terrain.generate_spawn_water_pond()
    local x = 1
    local surface = game.surfaces[1]
    for _, silo in pairs(storage.rocket_silo) do
        local pos = {}
        local wreck_pos = {}
        pos['x'] = silo.position.x + 60 * x
        pos['y'] = silo.position.y - 5 * x
        wreck_pos['x'] = silo.position.x + 60 * x
        wreck_pos['y'] = silo.position.y - 5 * x
        create_tile_cluster('water-green', pos, 450)
        local p = surface.find_non_colliding_position('big-ship-wreck-1', { wreck_pos.x, wreck_pos.y - 3 * x }, 20, 1)
        local e = surface.create_entity { name = 'big-ship-wreck-1', position = p, force = silo.force.name }
        e.insert({ name = 'copper-cable', count = 7 })
        e.insert({ name = 'iron-stick', count = 3 })
        local p = surface.find_non_colliding_position('big-ship-wreck-3', { pos.x - 3 * x, pos.y }, 20, 1)
        local e = surface.create_entity { name = 'big-ship-wreck-3', position = p, force = silo.force.name }
        e.insert({ name = 'land-mine', count = 6 })
        pos['x'] = silo.position.x - math.random(80, 90) * x
        pos['y'] = silo.position.y - math.random(50, 70) * x
        create_tile_cluster('water-green', pos, 300)
        local p = surface.find_non_colliding_position('big-ship-wreck-2', { pos.x + 3 * x, pos.y + 1 * x }, 20, 1)
        local e = surface.create_entity { name = 'big-ship-wreck-2', position = p, force = silo.force.name }
        e.insert({ name = 'barrel', count = 1 })
        e.insert({ name = 'lubricant-barrel', count = 2 })
        local p = surface.find_non_colliding_position('crude-oil', { pos.x - 5 * x, pos.y + 5 * x }, 50, 1)
        local e = surface.create_entity { name = 'crude-oil', position = p, amount = 225000 }
        x = -1
    end
end

function biter_battles_terrain.clear_spawn_ores()
    local surface = game.surfaces[1]
    for x = -200, 200, 1 do
        for y = -200, 200, 1 do
            local tile_distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
            if tile_distance_to_center < 150 then
                local entities = surface.find_entities({ { x, y }, { x + 1, y + 1 } })
                for _, e in pairs(entities) do
                    if e.type == 'resource' then
                        e.destroy()
                    end
                end
            end
        end
    end
end

function biter_battles_terrain.generate_spawn_ores(ore_layout)
    local surface = game.surfaces[1]
    local tiles = {}
    --generate ores around silos
    local ore_layout = 'windows'
    --local ore_layout = "4squares"
    local ore_amount = 1000

    if ore_layout == '4squares' then
        local size = 22
        for _, rocket_silo in pairs(storage.rocket_silo) do
            local tiles = {}
            for x = (size + 1) * -1, size + 1, 1 do
                for y = (size + 1) * -1, size + 1, 1 do
                    table.insert(tiles, { name = 'stone-path', position = { rocket_silo.position.x + x, rocket_silo.position.y + y } })
                end
            end
            surface.set_tiles(tiles, true)
            local entities = surface.find_entities({ { (rocket_silo.position.x - 4) - size / 2, (rocket_silo.position.y - 5) - size / 2 }, { rocket_silo.position.x + 4 + size / 2, rocket_silo.position.y + 5 + size / 2 } })
            for _, entity in pairs(entities) do
                if entity.type == 'simple-entity' or entity.type == 'tree' or entity.type == 'resource' then
                    entity.destroy()
                end
            end
        end
        for x = size * -1, size, 1 do
            for y = size * -1, size, 1 do
                if x > 0 and y < 0 then
                    if
                        surface.can_place_entity {
                            name = 'stone',
                            position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y },
                            amount = ore_amount
                        }
                    then
                        surface.create_entity {
                            name = 'stone',
                            position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y },
                            amount = ore_amount
                        }
                    end
                end
                if x < 0 and y < 0 then
                    if
                        surface.can_place_entity {
                            name = 'coal',
                            position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y },
                            amount = ore_amount
                        }
                    then
                        surface.create_entity {
                            name = 'coal',
                            position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y },
                            amount = ore_amount
                        }
                    end
                end
                if x < 0 and y > 0 then
                    if
                        surface.can_place_entity {
                            name = 'copper-ore',
                            position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y },
                            amount = ore_amount
                        }
                    then
                        surface.create_entity {
                            name = 'copper-ore',
                            position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y },
                            amount = ore_amount
                        }
                    end
                end
                if x > 0 and y > 0 then
                    if
                        surface.can_place_entity {
                            name = 'iron-ore',
                            position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y },
                            amount = ore_amount
                        }
                    then
                        surface.create_entity {
                            name = 'iron-ore',
                            position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y },
                            amount = ore_amount
                        }
                    end
                end
                if x < 0 and y > 0 then
                    if
                        surface.can_place_entity {
                            name = 'stone',
                            position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y },
                            amount = ore_amount
                        }
                    then
                        surface.create_entity {
                            name = 'stone',
                            position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y },
                            amount = ore_amount
                        }
                    end
                end
                if x > 0 and y > 0 then
                    if
                        surface.can_place_entity {
                            name = 'coal',
                            position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y },
                            amount = ore_amount
                        }
                    then
                        surface.create_entity {
                            name = 'coal',
                            position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y },
                            amount = ore_amount
                        }
                    end
                end
                if x > 0 and y < 0 then
                    if
                        surface.can_place_entity {
                            name = 'copper-ore',
                            position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y },
                            amount = ore_amount
                        }
                    then
                        surface.create_entity {
                            name = 'copper-ore',
                            position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y },
                            amount = ore_amount
                        }
                    end
                end
                if x < 0 and y < 0 then
                    if
                        surface.can_place_entity {
                            name = 'iron-ore',
                            position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y },
                            amount = ore_amount
                        }
                    then
                        surface.create_entity {
                            name = 'iron-ore',
                            position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y },
                            amount = ore_amount
                        }
                    end
                end
            end
        end
        for _, rocket_silo in pairs(storage.rocket_silo) do
            local entities = surface.find_entities({ { rocket_silo.position.x - 5, rocket_silo.position.y - 6 }, { rocket_silo.position.x + 5, rocket_silo.position.y + 6 } })
            for _, entity in pairs(entities) do
                if entity.type == 'resource' then
                    entity.destroy()
                end
            end
        end
    end

    if ore_layout == 'windows' then
        for x = -24, 24, 1 do
            for y = -25, 24, 1 do
                table.insert(tiles, { name = 'stone-path', position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y } })
                table.insert(tiles, { name = 'stone-path', position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y } })
            end
        end
        surface.set_tiles(tiles, true)
        local ore = {
            'stone',
            'stone',
            'stone',
            'stone',
            'coal',
            'coal',
            'coal',
            'coal',
            'coal',
            'copper-ore',
            'copper-ore',
            'copper-ore',
            'copper-ore',
            'copper-ore',
            'iron-ore',
            'iron-ore',
            'iron-ore',
            'iron-ore',
            'iron-ore'
        }
        for z = 1, 19, 1 do
            for x = -4 - z, 4 + z, 1 do
                for y = -5 - z, 4 + z, 1 do
                    if
                        surface.can_place_entity {
                            name = ore[z],
                            position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y },
                            amount = ore_amount
                        }
                    then
                        surface.create_entity {
                            name = ore[z],
                            position = { storage.rocket_silo['south'].position.x + x, storage.rocket_silo['south'].position.y + y },
                            amount = ore_amount
                        }
                    end
                end
            end
        end
        for z = 1, 19, 1 do
            for x = -4 - z, 4 + z, 1 do
                for y = -5 - z, 4 + z, 1 do
                    if
                        surface.can_place_entity {
                            name = ore[z],
                            position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y },
                            amount = ore_amount
                        }
                    then
                        surface.create_entity {
                            name = ore[z],
                            position = { storage.rocket_silo['north'].position.x + x, storage.rocket_silo['north'].position.y + y },
                            amount = ore_amount
                        }
                    end
                end
            end
        end
    end

    for _, rocket_silo in pairs(storage.rocket_silo) do
        local entities = surface.find_entities({ { rocket_silo.position.x - 4, rocket_silo.position.y - 5 }, { rocket_silo.position.x + 4, rocket_silo.position.y + 5 } })
        for _, entity in pairs(entities) do
            if entity.type == 'resource' then
                entity.destroy()
            end
        end
    end
end

Event.add(defines.events.on_chunk_generated, on_chunk_generated)

return biter_battles_ores
