// vtest build: !openbsd
import os
import time
import sokol.audio
import encoding.vorbis

fn main() {
	unbuffer_stdout()
	if os.args.len < 2 {
		eprintln('Usage: ogg_player file.ogg ...')
		play_sounds([os.resource_abs_path('pickup.ogg')])!
		exit(1)
	}
	play_sounds(os.args[1..])!
}

fn play_sounds(files []string) ! {
	mut player := Player{
		decoder: unsafe { nil }
	}
	player.init()
	for f in files {
		if !os.exists(f) || os.is_dir(f) {
			eprintln('skipping "${f}" (does not exist)')
			continue
		}
		fext := os.file_ext(f).to_lower()
		if fext != '.ogg' {
			eprintln('skipping "${f}" (not an .ogg file)')
			continue
		}
		player.play_ogg_file(f)!
	}
	player.stop()
}

struct Player {
mut:
	channels           int
	sample_rate        int
	pos                int
	finished           bool
	push_slack_ms      int = 5
	stream_rate        u32
	stream_channels    int
	stream_len_samples u32
	stream_len_seconds f32
	xerror             vorbis.VorbisErrorCode
	allocator          C.stb_vorbis_alloc = C.stb_vorbis_alloc{
		alloc_buffer:                 0
		alloc_buffer_length_in_bytes: 0
	}
	decoder            &C.stb_vorbis // TODO: cgen error with -cstrict -gcc, when this is = unsafe { nil } here
}

fn (mut p Player) init() {
	audio.setup()
	p.sample_rate = audio.sample_rate()
	p.channels = audio.channels()
	alloc_size := 200 * 1024
	p.allocator = C.stb_vorbis_alloc{
		alloc_buffer:                 unsafe { &char(vcalloc(alloc_size)) }
		alloc_buffer_length_in_bytes: alloc_size
	}
}

fn (mut p Player) stop() {
	p.free()
	audio.shutdown()
}

fn (mut p Player) free() {
	p.finished = false
	p.pos = 0
	p.close_decoder()
	unsafe { free(p.allocator.alloc_buffer) }
	unsafe {
		p.allocator.alloc_buffer = nil
	}
}

fn (mut p Player) close_decoder() {
	if !isnil(p.decoder) {
		C.stb_vorbis_close(p.decoder)
	}
}

fn (mut p Player) play_ogg_file(fpath string) ! {
	p.close_decoder()
	p.pos = 0
	p.xerror = .no_error
	p.decoder = C.stb_vorbis_open_filename(&char(fpath.str), voidptr(&p.xerror), &p.allocator)
	if isnil(p.decoder) || p.xerror != .no_error {
		return error('could not open ogg file: ${fpath}, xerror: ${p.xerror}')
	}
	info := C.stb_vorbis_get_info(p.decoder)
	p.stream_rate = info.sample_rate
	p.stream_channels = info.channels
	p.stream_len_samples = C.stb_vorbis_stream_length_in_samples(p.decoder)
	p.stream_len_seconds = C.stb_vorbis_stream_length_in_seconds(p.decoder)
	p.finished = false

	if !(p.channels == p.stream_channels && p.sample_rate == p.stream_rate) {
		audio.shutdown()
		audio.setup(
			num_channels: p.stream_channels
			sample_rate:  int(p.stream_rate)
		)
		p.sample_rate = audio.sample_rate()
		p.channels = audio.channels()
	}
	println('> play_ogg_file: rate: ${p.sample_rate:5}, channels: ${p.channels:1} | stream rate: ${p.stream_rate:5}, channels: ${p.stream_channels:1}, samples: ${p.stream_len_samples:8} | seconds: ${p.stream_len_seconds:7.3f} | ${fpath}')

	frames := [16384]f32{}
	pframes := unsafe { &frames[0] }
	for !p.finished {
		mut delay := p.push_slack_ms
		expected_frames := audio.expect()
		if expected_frames > 0 {
			mut decoded_frames := 0
			for decoded_frames < expected_frames {
				samples := C.stb_vorbis_get_samples_float_interleaved(p.decoder, p.channels,
					pframes, 1024)
				if samples == 0 {
					p.finished = true
					break
				}
				written_frames := audio.push(pframes, samples)
				decoded_frames += written_frames
				p.pos += samples
			}
			delay = (1_000 * decoded_frames) / p.sample_rate
		}
		print('\r  position: ${p.pos:9} / ${p.stream_len_samples:-9} samples | ${p.pos * p.stream_len_seconds / p.stream_len_samples:7.3f} / ${p.stream_len_seconds:-7.3f} seconds')
		time.sleep(int_max(p.push_slack_ms, delay - p.push_slack_ms) * time.millisecond)
	}
	println('')
}