package engine

import os "core:os/os2"
import "core:container/queue"
import "core:log"

import "ljud"

Sound :: struct {
    path: string, // Where I was loaded from.
    data: []u8,
    backend: ^Sound_Backend, // Backend-representation.
}

Sound_Instance :: struct {
    parent: ^Sound, // What I'm an instance of.
    backend: Sound_Instance_Backend, // Backend-representation.

    spatialized: bool,
    volume: f32, // 0..1
    position: [3]f32,
    min_distance, max_distance: f32,
    // ..
}

Sound_Instance_ID :: distinct u32

load_sound_from_path :: proc(engine: ^Engine, path: string) -> (Sound, bool) {
    assert(engine != nil)

    if len(path) == 0 {
        return {}, false
    }

    base, ext := os.split_filename(path)
    log.info("Loading sound '%v' with extension '%v'.", base, ext)

    // TODO: SS - Check extension.
    
    data, err := os.read_entire_file(path, context.allocator)
    if err != nil {
        log.errorf("Failed to load sound! Could not read entire file. Error: %v", err)
        return {}, false
    }

    if len(data) == 0 {
        log.errorf("Failed to load sound! No data.")
        return {}, false
    }

    when AUDIO_ENGINE_LJUD {
        backend, ok := ljud.load_sound_from_data(&engine.backend, data, ext)
        if !ok {
            return {}, false
        }
        assert(backend != nil)

        log.info("Loaded sound, returning")

        return Sound {
            path = path,
            data = data,
            backend = backend,
        }, true
    }
    else when AUDIO_ENGINE_FMOD {
        
    }
    else when AUDIO_ENGINE_WWISE {
        
    }
    
    log.info("No engine defined")
    
    return {}, false
}

unload_sound :: proc(engine: ^Engine, sound: ^Sound) {
    assert(engine != nil)
    assert(sound != nil)
    assert(sound.data != nil)
    
    when AUDIO_ENGINE_LJUD {
        ljud.unload_sound(&engine.backend, sound.backend)
    }
    else when AUDIO_ENGINE_FMOD {
        
    }
    else when AUDIO_ENGINE_WWISE {
        
    }

    delete(sound.data)
    sound.data = nil
    
    free(sound.backend)
    sound.backend = nil
}

create_sound_instance :: proc(engine: ^Engine, sound: ^Sound, bus: ^Bus) -> (^Sound_Instance, bool) {
    assert(engine != nil)
    assert(sound != nil)

    // TODO: SS - Get an available instance from a pre-allocated buffer.

    sound_instance_id, pop_ok := queue.pop_front_safe(&engine.sound_instance_ids)
    if !pop_ok {
        log.warnf("No free sound-instance available.")
        return {}, false
    }
    
    sound_instance := &engine.sound_instances[sound_instance_id]
    assert(sound_instance != nil)

    sound_instance.parent = sound
    sound_instance.backend = {}

    instance_ok: bool
    when AUDIO_ENGINE_LJUD {
        instance_ok = ljud.init_sound_instance(&engine.backend, bus != nil ? bus.backend : nil, sound.backend, &sound_instance.backend)
    }
    else when AUDIO_ENGINE_FMOD {
        
    }
    else when AUDIO_ENGINE_WWISE {
        
    }

    if !instance_ok {
        log.errorf("Failed to create a Sound-Instance for sound '%v'.", sound.path)
        return nil, false
    }

    return sound_instance, true
}

play_sound_instance :: proc(engine: ^Engine, sound_instance: ^Sound_Instance) -> bool {
    assert(engine != nil)
    assert(sound_instance != nil)

    when AUDIO_ENGINE_LJUD {
        spec := ljud.Play_Sound_Instance_Spec {
            spatialized = sound_instance.spatialized,
            volume = sound_instance.volume,

            position = sound_instance.position,
            distance = {
                min = sound_instance.min_distance,
                max = sound_instance.max_distance,
            },
        }
        return ljud.play_sound_instance(&engine.backend, &sound_instance.backend, spec)
    }
    else when AUDIO_ENGINE_FMOD {
    }
    else when AUDIO_ENGINE_WWISE {
        
    }

    return false
}