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();
	}
}