--luacheck: ignore
--spaghettorio-- mewmew made this -- inspired by redlabel

local simplex_noise = require 'utils.math.simplex_noise'
simplex_noise = simplex_noise.d2
local event = require 'utils.event'

local function disable_recipes()
    game.forces.player.recipes['splitter'].enabled = false
    game.forces.player.recipes['fast-splitter'].enabled = false
    game.forces.player.recipes['express-splitter'].enabled = false
    game.forces.player.recipes['steam-engine'].enabled = false
    game.forces.player.recipes['boiler'].enabled = false
    game.forces.player.recipes['assembling-machine-1'].enabled = false
    game.forces.player.recipes['assembling-machine-2'].enabled = false
    game.forces.player.recipes['assembling-machine-3'].enabled = false
    game.forces.player.recipes['steel-furnace'].enabled = false
    game.forces.player.recipes['chemical-plant'].enabled = false
    game.forces.player.recipes['centrifuge'].enabled = false
    game.forces.player.recipes['heat-exchanger'].enabled = false
    game.forces.player.recipes['steam-turbine'].enabled = false
    game.forces.player.recipes['oil-refinery'].enabled = false
    game.forces.player.recipes['lab'].enabled = false
end

local function on_player_joined_game(event)
    local player = game.players[event.player_index]
    if not storage.map_init_done then
        local map_gen_settings = {}
        map_gen_settings.water = 'none'
        game.create_surface('spaghettorio', map_gen_settings)
        game.forces['player'].set_spawn_position({ 0, 0 }, game.surfaces['spaghettorio'])
        game.forces['player'].technologies['logistic-system'].enabled = false
        storage.map_init_done = true
    end
    local surface = game.surfaces['spaghettorio']
    if player.online_time < 5 and surface.is_chunk_generated({ 0, 0 }) then
        player.teleport(surface.find_non_colliding_position('character', { 0, 0 }, 2, 1), 'spaghettorio')
    else
        if player.online_time < 5 then
            player.teleport({ 0, 0 }, 'spaghettorio')
        end
    end
    disable_recipes()
end

local function get_noise(name, pos)
    local seed = game.surfaces[1].map_gen_settings.seed
    local noise = {}
    local noise_seed_add = 25000
    if name == 'water' then
        noise[1] = simplex_noise(pos.x * 0.002, pos.y * 0.002, seed)
        seed = seed + noise_seed_add
        noise[2] = simplex_noise(pos.x * 0.01, pos.y * 0.01, seed)
        seed = seed + noise_seed_add
        local noise = noise[1] + noise[2] * 0.2
        return noise
    end
    seed = seed + noise_seed_add
    if name == 'assembly' then
        noise[1] = simplex_noise(pos.x * 0.004, pos.y * 0.004, seed)
        seed = seed + noise_seed_add
        local noise = noise[1]
        return noise
    end
end

local splitter_raffle = { 'splitter', 'splitter', 'splitter', 'fast-splitter', 'fast-splitter', 'express-splitter' }
local assembly_raffle = {
    'assembling-machine-1',
    'assembling-machine-2',
    'assembling-machine-1',
    'assembling-machine-2',
    'assembling-machine-3',
    'assembling-machine-1',
    'assembling-machine-2',
    'assembling-machine-1',
    'assembling-machine-2',
    'assembling-machine-3',
    'chemical-plant',
    'chemical-plant',
    'chemical-plant',
    'oil-refinery',
    'lab'
}
local smelting_raffle = { 'steel-furnace', 'stone-furnace' }
local steampower_raffle = { 'steam-engine', 'steam-engine', 'boiler' }
local nuclearpower_raffle = { 'steam-turbine', 'steam-turbine', 'steam-turbine', 'heat-exchanger', 'heat-exchanger', 'centrifuge' }
local direction_raffle = { 0, 2, 4, 6 }

local function on_chunk_generated(event)
    local surface = game.surfaces['spaghettorio']
    if event.surface.name ~= surface.name then
        return
    end
    local entities = {}
    local tiles = {}
    local math_random = math.random

    for x = 0, 31, 1 do
        for y = 0, 31, 1 do
            local pos = { x = event.area.left_top.x + x, y = event.area.left_top.y + y }
            local noise_water = get_noise('water', pos)
            local noise_assembly = get_noise('assembly', pos)
            while true do
                if noise_water > 0.8 or noise_water < -0.8 then
                    table.insert(tiles, { name = 'water', position = pos })
                    break
                end
                if noise_water > 0.68 then
                    if math_random(1, 50) == 1 then
                        local a = {
                            left_top = { x = pos.x - 75, y = pos.y - 75 },
                            right_bottom = { x = pos.x + 75, y = pos.y + 75 }
                        }
                        local z = surface.count_tiles_filtered { area = a, limit = 1, name = 'water' }
                        if z == 1 then
                            table.insert(entities, { name = steampower_raffle[math_random(1, #steampower_raffle)], position = pos })
                        end
                    end
                    break
                end
                if noise_water < -0.7 then
                    if math_random(1, 100) == 1 then
                        local a = {
                            left_top = { x = pos.x - 75, y = pos.y - 75 },
                            right_bottom = { x = pos.x + 75, y = pos.y + 75 }
                        }
                        local z = surface.count_tiles_filtered { area = a, limit = 1, name = 'water' }
                        if z == 1 then
                            table.insert(entities, { name = nuclearpower_raffle[math_random(1, #nuclearpower_raffle)], position = pos })
                        end
                    end
                    break
                end
                if noise_assembly > 0.6 then
                    if math_random(1, 75) == 1 then
                        table.insert(entities, { name = assembly_raffle[math_random(1, #assembly_raffle)], position = pos })
                    end
                end
                if noise_assembly < -0.8 then
                    if math_random(1, 35) == 1 then
                        table.insert(entities, { name = smelting_raffle[math_random(1, #smelting_raffle)], position = pos })
                    end
                end
                if math_random(1, 250) == 1 then
                    if noise_assembly < -0.6 or noise_assembly > 0.6 or noise_water < -0.6 or noise_water > 0.6 then
                        table.insert(entities, { name = splitter_raffle[math_random(1, #splitter_raffle)], position = pos })
                    end
                end
                break
            end
        end
    end
    surface.set_tiles(tiles, true)

    for _, e in pairs(entities) do
        local d = direction_raffle[math_random(1, #direction_raffle)]
        if surface.can_place_entity({ name = e.name, position = e.position, direction = d }) then
            local entity = surface.create_entity { name = e.name, position = e.position, direction = d, force = 'player' }
            entity.minable = false
            entity.destructible = false
            if entity.name == 'stone-furnace' or entity.name == 'steel-furnace' then
                entity.energy = 1
            end
        end
    end
end

local disabled_entities = { 'stone-furnace', 'electric-furnace', 'solar-panel' }
local function on_built_entity(event)
    for _, e in pairs(disabled_entities) do
        if e == event.entity.name then
            if event.player_index then
                local player = game.players[event.player_index]
                player.insert({ name = event.entity.name, count = 1 })
            end
            event.entity.destroy()
        end
    end
end

local function on_robot_built_entity(event)
    on_built_entity(event)
end

local function on_research_finished(event)
    disable_recipes()
end

event.add(defines.events.on_research_finished, on_research_finished)
event.add(defines.events.on_robot_built_entity, on_robot_built_entity)
event.add(defines.events.on_built_entity, on_built_entity)
event.add(defines.events.on_chunk_generated, on_chunk_generated)
event.add(defines.events.on_player_joined_game, on_player_joined_game)