package main

import "core:bytes"
import "core:fmt"
import "core:io"
import "core:os"
import "core:time"

main :: proc() {
	if len(os.args) < 2 {
		panic("no file")
	}

	filepath := os.args[1]
	file, err := os.open(filepath)
	if err != os.ERROR_NONE {
		panic("could not open file")
	}
	defer os.close(file)

	fmt.printf("%s\n", filepath)
	reader: io.Reader
	seeker: io.Seeker
	ok: bool
	reader, ok = io.to_reader(os.stream_from_handle(file))
	if !ok {
		panic("could not reader")
	}
	seeker, ok = io.to_seeker(os.stream_from_handle(file))
	if !ok {
		panic("could not seeker")
	}

	body_length: u32
	{
		io.read_ptr(reader, &body_length, 4)
		fmt.printf("body_length: %d\n", body_length)
	}
	file_length: u32
	{
		io.read_ptr(reader, &file_length, 4)
		fmt.printf("file_length: %d\n", file_length)
	}

	index_length := file_length - body_length
	fmt.printf("index_length: %d\n", index_length)
	content_marks := make([]u32, index_length)
	for i in 0 ..< index_length {
		io.read_ptr(reader, &content_marks[i], 4)
	}
	// fmt.printf("%v#%d\n", content_marks, len(content_marks))
	fmt.printf("#%d marks\n", len(content_marks))

	content_offset := 8 + (index_length * 4)
	io.seek(seeker, i64(content_offset), .Start)

	buffer: [4096]byte
	prev_mark: u32
	for mark in content_marks {
		length := mark - prev_mark
		line := buffer[:length]
		fmt.printf("\nblock %d-%d\n", prev_mark, mark)

		io.read_full(reader, line)
		/*for c in line {
			fmt.printf("%c", c)
		}
		fmt.printf("\n")*/

		buffer: bytes.Buffer
		bytes.buffer_init(&buffer, line)
		defer bytes.buffer_destroy(&buffer)

		{
			timestamp: u32
			bytes.buffer_read_ptr(&buffer, &timestamp, 4)
			filter, _ := bytes.buffer_read_byte(&buffer)
			channel, _ := bytes.buffer_read_byte(&buffer)

			unix_time := time.unix(i64(timestamp), 0)
			fmt.printf(
				"%d - %d/%02d/%02d@%02d:%02d:%02d - %x %x\n",
				timestamp,
				time.date(unix_time),
				time.clock_from_time(unix_time),
				filter,
				channel,
			)
		}

		for bytes.buffer_length(&buffer) > 0 {
			b, _ := bytes.buffer_read_byte(&buffer)
			if b == 0x02 {
				fmt.printf("[")

				kind, _ := bytes.buffer_read_byte(&buffer)
				fmt.printf("0x%02x=", kind)
				size, _ := bytes.buffer_read_byte(&buffer)
				fmt.printf("%d, ", size)

				for _ in 0 ..< size {
					b, _ = bytes.buffer_read_byte(&buffer)
					if b >= 32 && b <= 126 {
						fmt.printf("%c", b)
					} else {
						if b == 0x03 {
							fmt.printf("]")
						} else {
							fmt.printf("0x%02x ", b)
						}
					}
				}
			} else {
				// fmt.printf("(0x%02x) %c ", b, b)
				fmt.printf("%c", b)
			}
		}
		fmt.printf("\n")

		prev_mark = mark
	}
}