package main

import "core:fmt"
import "core:mem"
import "core:os"
import "core:path/filepath"

import "../core"

run_app :: proc() -> bool {
	db_path, err := core.storage_look_up_db_path()
	if err != nil {
		fmt.eprintf("run_app: os.make_directory error -> %v\n", os.error_string(err))
		return false
	}

	fmt.printf("%s🧌 data goblin sync%s", core.BOLD, core.RESET)
	fmt.printf(
		" %s·%s %s%s%s %s@ %s%s\n",
		core.DIM,
		core.RESET,
		core.GREEN,
		filepath.base(db_path),
		core.RESET,
		core.DIM,
		filepath.dir(db_path),
		core.RESET,
	)

	store: core.Storage
	if err := core.storage_open(&store, db_path); err != nil {
		fmt.eprintf("run_app: storage.open error -> %v\n", err)
		return false
	}

	if err := core.storage_ensure_schema(store); err != nil {
		fmt.eprintf("run_app: storage.ensure_schema error -> %v\n", err)
		return false
	}

	if err := core.storage_close(&store); err != nil {
		fmt.eprintf("run_app: storage.close error -> %v\n", err)
		return false
	}

	return true
}

main :: proc() {
	when ODIN_DEBUG {
		track: mem.Tracking_Allocator
		mem.tracking_allocator_init(&track, context.allocator)
		context.allocator = mem.tracking_allocator(&track)

		defer {
			for _, leak in track.allocation_map {
				fmt.printf("%v leaked %m\n", leak.location, leak.size)
			}
			mem.tracking_allocator_destroy(&track)
		}
	}

	if !run_app() {
		fmt.printf("🧌 the goblin is confused. · %sexit 1%s\n", core.RED, core.RESET)
		os.exit(-1)
	}

	fmt.printf("🧌 the goblin returns to the hoard.\n")
	free_all(context.temp_allocator)
}