package org.warp.jcwdb;

import it.unimi.dsi.fastutil.longs.LongArrayList;

import java.io.IOException;
import java.nio.file.Path;

public class JCWDatabase implements AutoCloseable, Cleanable {
	public final static long MAX_LOADED_INDICES = 10000;

	private final TypesManager typesManager;
	private final MixedIndexDatabase indices;
	private final Cleaner databaseCleaner;
	private final EntryReferenceTools entryReferenceTools = new EntryReferenceTools();
	private volatile boolean closed;
	private final Object closeLock = new Object();
	private final Object indicesAccessLock = new Object();

	public JCWDatabase(Path dataFile, Path metadataFile) throws IOException {
		this.typesManager = new TypesManager(this);
		this.indices = new MixedIndexDatabase(dataFile, metadataFile);
		Runtime.getRuntime().addShutdownHook(new Thread(() -> {
			try {
				JCWDatabase.this.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}));
		this.databaseCleaner = new Cleaner(this);

		this.databaseCleaner.start();
	}

	public <T> EntryReference<LightList<T>> getRoot() throws IOException {
		return getRoot(Object.class).cast();
	}

	public <T> EntryReference<LightList<T>> getRoot(Class<T> clazz) throws IOException {
		checkClosed();
		if (exists(0)) {
			return get(0);
		} else {
			LightList<T> newRoot = new LightList<T>(this, new LongArrayList());
			return set(0, newRoot);
		}
	}

	public <T> EntryReference<T> get(long index) throws IOException {
		checkClosed();
		int type;
		long hash;
		synchronized (indicesAccessLock) {
			type = this.indices.getType(index);
			hash = this.indices.getHash(index);
		}
		DBTypeParser<T> typeParser = this.typesManager.get(type);
		return new EntryReference<>(entryReferenceTools, index, hash, typeParser);
	}

	protected <T> EntryReference<T> add(T value) throws IOException {
		checkClosed();
		DBTypeParser<T> typeParser = this.typesManager.get((Class<T>) value.getClass());
		long index;
		long hash;
		synchronized (indicesAccessLock) {
			index = indices.add(typeParser.getWriter(value));
			hash = indices.getHash(index);
		}
		return new EntryReference<>(entryReferenceTools, index, hash, typeParser, value);
	}

	protected boolean exists(long index) {
		checkClosed();
		synchronized (indicesAccessLock) {
			return this.indices.has(index);
		}
	}

	protected <T> EntryReference<T> set(long index, T value) throws IOException {
		checkClosed();
		EntryReference<T> ref;
		if (exists(index)) {
			ref = get(index);
			ref.setValue(value);
			return ref;
		} else {
			@SuppressWarnings("unchecked")
			DBTypeParser<T> typeParser = this.typesManager.get((Class<T>) value.getClass());
			long hash;
			synchronized (indicesAccessLock) {
				IndexDetails returnedDetails = indices.set(index, typeParser.getWriter(value));
				hash = returnedDetails.getHash();
			}
			return new EntryReference<>(entryReferenceTools, index, hash, typeParser);
		}
	}

	public <U> void registerType(Class<U> clazz, short type, DBTypeParser<U> parser) {
		final int addition = 0xEFFF8000;
		int extendedType = addition | (type & 0x7FFF);
		typesManager.registerType(clazz, extendedType, parser);
	}

	public <U> void registerClass(Class<U> clazz, int type) {
		typesManager.registerGenericClass(clazz, type);
	}

	public boolean isOpen() {
		return !closed;
	}

	@Override
	public void close() throws IOException {
		if (closed) {
			return;
		}
		synchronized (closeLock) {
			if (closed) {
				return;
			}
			closed = true;
		}

		this.databaseCleaner.stop();

		synchronized (indicesAccessLock) {
			this.indices.close();
		}
		System.out.println("Database closed.");
	}

	private void checkClosed() {
		if (closed) {
			throw new RuntimeException("Index Manager is closed.");
		}
	}

	@Override
	public long clean() {
		long removedItems = indices.clean();
		return removedItems;
	}

	public class EntryReferenceTools {
		private EntryReferenceTools() {

		}

		public <T> T read(long index, DBReader<T> reader) throws IOException {
			return indices.get(index, reader);
		}

		public <T> IndexDetails write(long index, DBDataOutput<T> writer) throws IOException {
			return indices.set(index, writer);
		}
	}

	@SuppressWarnings("unchecked")
	protected <T> long calculateHash(T o) {
		return ((DBTypeParser<T>) typesManager.get(o.getClass())).calculateHash(o);
	}

}