local print = epoe.Print
local me = me
-- config / gmod specific

local SOUNDS = {
    hi = "ambient/levels/prison/radio_random11.wav",
    oh = "ambient/water/rain_drip4.wav",
    boop = "buttons/button16.wav",
}

local MODIFIERS = {
    ["--"] = {
        args = {
            function(stop_percent) return tonumber(stop_percent) or 100 end
        },

        init = function(self, stop_percent)
            self.duration = self.duration / (stop_percent / 100)
        end,
    },
    ["="] = {
        args = {
            function(time) return tonumber(time) or 0 end
        },

        init = function(self, time)
            self.duration = time
        end,
    },
    ["%"] = {
        args = {
            function(pitch) return math.Clamp(tonumber(pitch) or 100, 0, 255) end,
            function(time) return tonumber(time) or 0 end,
        },

        init = function(self, pitch, time)
            self.duration = self.duration / (pitch / 100)
            self.duration = self.duration + time
        end,

        think = function(self, pitch, time)
            if self.csp then
                self.csp:ChangePitch(pitch, time)

            end
        end,
    },
    ["^"] = {
        args = {
            function(volume) return math.Clamp(tonumber(volume) or 1, 0, 1) end,
            function(time) return tonumber(time) or 0 end,
        },

        think = function(self, volume, time)
            if self.csp then
                if self.source_entity == LocalPlayer() then
                    volume = volume / 2
                end

                self.csp:ChangeVolume(volume / 100, time)
            end
        end,
    }
}

local function PLAY_SOUND(self)
    local csp = CreateSound(me, self.path)
    csp:PlayEx(1, 0)
    self.source_entity = me
    self.csp = csp
end

local function STOP_SOUND(self)
    if self.csp then
        self.csp:Stop()
    end
end

local function GET_DURATION(self)
    return SoundDuration(self.path) or 0
end

--
local cache = {}

local function parse(str)
    if cache[str] then return cache[str] end

    local out = {}

    -- lowercase it so we don't have to deal with case sensitivity
    str = str:lower()

    -- add a last space so it matches the end as well
    str = str .. " "

    -- split the input by either space or ;
    for line in str:gmatch("(.-)%s") do
        local key, mods = line:match("([a-z_]+)([%p%d]+)")

        -- if it doesn't have a modifier, use the whole line
        if not key then
            key = line
        end

        local modifiers = {}

        if mods then
            for mod, args in mods:gmatch("(%p+)([%d%.,]+)") do
                if args then
                    -- add a last . so it matches the end as well
                    args = args .. ","

                    local temp = {}

                    -- split the args by .
                    for arg in args:gmatch("(.-),") do

                        -- if it's a number make it a number, otherwise leave it as string
                        arg = tonumber(arg) or arg

                        table.insert(temp, arg)
                    end

                    modifiers[mod] = temp
                end
            end
        end

        table.insert(out, {key = key, modifiers = modifiers})
    end

    cache[str] = out

    return out
end

local function play(sounds)
    local id = "LOL_" ..tostring(sounds)
    local active_sounds = {}

    hook.Add("RenderScene", id, function()
        for key, data in pairs(active_sounds) do
            if data.stop_time < SysTime() then
                active_sounds[key] = nil
                if data.last_sound then
                    hook.Remove("RenderScene", id)
                end
            else
                data:think()
            end
        end
    end)

    -- copy the table since we're going to modify it
    sounds = table.Copy(sounds)

    for i, data in ipairs(sounds) do
        local path = SOUNDS[data.key]

        if path then
            data.path = path
            data.duration = GET_DURATION(data)

            data.play = function(self)
                PLAY_SOUND(self)
            end

            data.stop = function(self)
                STOP_SOUND(self)
            end

            -- only add a think function if the modifier exists
            if data.modifiers then

                -- if args is defined use it to default and clamp the arguments
                for mod, args in pairs(data.modifiers) do
                    mod = MODIFIERS[mod]
                    if mod and mod.args then
                        for i, func in pairs(mod.args) do
                            args[i] = func(args[i])
                        end
                    end
                end

                data.think = function(self)
                    for mod, args in pairs(self.modifiers) do
                        mod = MODIFIERS[mod]
                        if mod and mod.think then
                            mod.think(self, unpack(args))
                        end
                    end
                end
            end
        end
    end

    -- play it
    local duration = 0
    local last

    for i, data in ipairs(sounds) do

        if data.play then

            -- let it be able to think once first so we can modify duration and such when changing pitch
            if data.think then
                data:think()
            end

            for mod, args in pairs(data.modifiers) do
                local mod = MODIFIERS[mod]
                if mod and mod.init then
                    mod.init(data, unpack(args))
                end
            end

            timer.Simple(duration, function()
                if last then
                    last:stop()
                end

                data.stop_time = SysTime() + data.duration
                if i == #sounds then
                    data.last_sound = true
                end

                data:play()

                if data.think then
                    table.insert(active_sounds, data)
                end

                last = data
            end)

            duration = duration + data.duration
        end

    end
end

local data = parse(
[[
boop%100=0.125
boop%100=0.125
boop%50=0.5
boop%50=0.5
boop%50=0.35
boop%50=0.40

boop%100=0.125
boop%100=0.125
boop%50=0.5
boop%50=0.5
boop%50=0.35
boop%50=1
]])

play(data)

local data = parse(
[[
hi%100=0.5
hi%100=0.5
hi%100=0.5
hi%100=0.5
hi%100=0.5
hi%100=0.5
hi%100=0.5
hi%100=0.5
]])

play(data)