package lib;

import haxe.Serializer;
import haxe.Unserializer;
import kernel.fs.FS;
import haxe.ds.StringMap;

/**
	Key value store with persistence.
**/
class KVStore {
	private var kvStore:StringMap<Dynamic> = new StringMap();

	public final namespace:String;

	public function new(namespace:String) {
		this.namespace = namespace;
		this.load();
	}

	public static function removeNamespace(namespace:String):Void {
		var nsFile = getNamespaceFile(namespace);
		FS.delete(nsFile);
	}

	public static function getStoreForClass(?pos:haxe.PosInfos) {
		var className = pos.className;
		return new KVStore(className);
	}

	private static function getNamespaceFile(namespace:String):String {
		return '/var/ns/$namespace';
	}

	public function load() {
		var nsFile = getNamespaceFile(this.namespace);
		if (FS.exists(nsFile)) {
			var handle = FS.openRead(nsFile);
			parseFile(handle.readAll());
		}
	}

	public function save() {
		var handle = FS.openWrite(getNamespaceFile(this.namespace));

		handle.write(Serializer.run(this.kvStore));

		handle.close();
	}

	private function parseFile(content:String) {
		var unserializer = new Unserializer(content);
		this.kvStore = unserializer.unserialize();
	}

	public inline function set(key:String, value:Dynamic) {
		this.kvStore.set(key, value);
	}

	public inline function get<T>(key:String, ?orElse:T = null):Null<T> {
		return this.kvStore.get(key) ?? orElse;
	}

	public inline function exists(key:String):Bool {
		return this.kvStore.exists(key);
	}

	public inline function clear() {
		this.kvStore.clear();
	}

	public inline function remove(key:String):Bool {
		return this.kvStore.remove(key);
	}

	public inline function keys():Iterator<String> {
		return this.kvStore.keys();
	}

	public inline function keyValueIterator():KeyValueIterator<String, Dynamic> {
		return this.kvStore.keyValueIterator();
	}
}