package audio

import "core:log"

import "engine"

Sound :: engine.Sound
Sound_Instance :: engine.Sound_Instance
Bus :: engine.Bus
Listener :: engine.Listener

Context :: struct {
    engine: engine.Engine,
}

init :: proc(ctx: ^Context, max_sound_instances: u32) -> bool {
    assert(ctx != nil)
    ok := engine.init(&ctx.engine, max_sound_instances)

    return ok
}

tick :: proc(ctx: ^Context) {
    assert(ctx != nil)
    engine.tick(&ctx.engine)
}

shutdown :: proc(ctx: ^Context) {
    assert(ctx != nil)
    engine.shutdown(&ctx.engine)
}


create_bus :: proc(ctx: ^Context) -> (Bus, bool) {
    assert(ctx != nil)

    bus, ok := engine.create_bus(&ctx.engine)
    if !ok {
        return {}, false
    }

    return bus, ok
}

destroy_bus :: proc(ctx: ^Context, bus: ^Bus) {
    assert(ctx != nil)
    assert(bus != nil)

    engine.destroy_bus(&ctx.engine, bus)
}

create_listener :: proc(ctx: ^Context) -> (^Listener, bool) {
    assert(ctx != nil)
    return engine.create_listener(&ctx.engine)
}

destroy_listener :: proc(ctx: ^Context, listener: ^Listener) {
    assert(ctx != nil)
    engine.destroy_listener(&ctx.engine, listener)
}

load_sound :: proc {
    load_sound_from_path,    
}

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

    sound, ok := engine.load_sound_from_path(&ctx.engine, path)
    if !ok {
        return {}, false
    }

    return sound, true
}

unload_sound :: proc(ctx: ^Context, sound: ^Sound) {
    assert(ctx != nil)
    assert(sound != nil)

    engine.unload_sound(&ctx.engine, sound)
}

play_sound :: proc {
    play_sound_at_position,
}

play_sound_at_position :: proc(ctx: ^Context, sound: ^Sound, bus: ^Bus, position: [3]f32) -> (^Sound_Instance, bool) {
    assert(ctx != nil)

    sound_instance, ok := engine.create_sound_instance(&ctx.engine, sound, bus)
    if !ok {
        log.warnf("Failed to play sound! Failed to create a sound instance.")
        return nil, false
    }

    sound_instance.spatialized = true // TEMP: SS - Hardcoded. Expose!
    sound_instance.loop = false // TEMP: SS - Hardcoded. Expose!
    sound_instance.volume = 1.0 // TEMP: SS - Hardcoded. Expose!
    sound_instance.position = position
    sound_instance.min_distance = 1.0 // TEMP: SS - Hardcoded. Expose!
    sound_instance.max_distance = 50.0 // TEMP: SS - Hardcoded. Expose!

    if !engine.play_sound_instance(
        &ctx.engine,
        sound_instance
    ) {
        log.warnf("Failed to play sound instance.")
        return nil, false
    }

    return sound_instance, true
}

// TODO: SS - 'get_sound_instance_status(..)' that returns an enum for the state; not started, playing, stopped, done?
// TODO: SS - 'stop_sound_instance(..)'
// TODO: SS - 'update_sound_instance(..)' that allows us to, for example, move the sound; projectile moving, bird flying, coin swaying, etc.

update_listener :: proc(ctx: ^Context, listener: ^Listener, position, velocity, direction_forward, world_up: [3]f32) -> bool {
    assert(ctx != nil)
    assert(listener != nil)

    if listener.id == engine.INVALID_LISTENER_ID {
        return false
    }

    listener.position = position
    listener.velocity = velocity
    listener.direction_forward = direction_forward
    listener.world_up = world_up

    return true
}