package org.argeo.api.gcr.fs;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.WatchEvent.Kind;
import java.nio.file.WatchEvent.Modifier;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;

public abstract class AbstractFsPath<FS extends AbstractFsSystem<ST>, ST extends AbstractFsStore> implements Path {
	private final FS fs;
	/** null for non absolute paths */
	private final ST fileStore;

	private final String[] segments;// null means root
	private final boolean absolute;

	private final String separator;

	// optim
	private final int hashCode;

	public AbstractFsPath(FS filesSystem, String path) {
		if (path == null)
			throw new IllegalArgumentException("Path cannot be null");
		this.fs = filesSystem;
		this.separator = fs.getSeparator();
		// TODO deal with both path and separator being empty strings
		if (path.equals(separator)) {// root
			this.segments = null;
			this.absolute = true;
			this.hashCode = 0;
			this.fileStore = fs.getBaseFileStore();
			return;
		} else if (path.equals("")) {// empty path
			this.segments = new String[] { "" };
			this.absolute = false;
			this.hashCode = "".hashCode();
			this.fileStore = null;
			return;
		}

		this.absolute = path.startsWith(toStringRoot());

		String trimmedPath = path.substring(absolute ? toStringRoot().length() : 0,
				path.endsWith(separator) ? path.length() - separator.length() : path.length());
		this.segments = trimmedPath.split(separator);
		// clean up
		for (int i = 0; i < this.segments.length; i++) {
			this.segments[i] = cleanUpSegment(this.segments[i]);
		}
		this.hashCode = this.segments[this.segments.length - 1].hashCode();

		this.fileStore = isAbsolute() ? fs.getFileStore(path) : null;
	}

	protected AbstractFsPath(FS filesSystem, ST fileStore, String[] segments, boolean absolute) {
		this.segments = segments;
		this.absolute = absolute;
		this.hashCode = segments == null ? 0 : segments[segments.length - 1].hashCode();
		this.separator = filesSystem.getSeparator();
//		super(path, path == null ? true : absolute, filesSystem.getSeparator());
//		assert path == null ? absolute == true : true;
		this.fs = filesSystem;
//		this.path = path;
//		this.absolute = path == null ? true : absolute;
		if (isAbsolute() && fileStore == null)
			throw new IllegalArgumentException("Absolute path requires a file store");
		if (!isAbsolute() && fileStore != null)
			throw new IllegalArgumentException("A file store should not be provided for a relative path");
		this.fileStore = fileStore;
		assert !(absolute && fileStore == null);
	}

	protected Path retrieve(String path) {
		return getFileSystem().getPath(path);
	}

	@Override
	public FS getFileSystem() {
		return fs;
	}

	public ST getFileStore() {
		return fileStore;
	}

	@Override
	public boolean isAbsolute() {
		return absolute;
	}

	@Override
	public URI toUri() {
		try {
			return new URI(fs.provider().getScheme(), toString(), null);
		} catch (URISyntaxException e) {
			throw new IllegalStateException("Cannot create URI for " + toString(), e);
		}
	}

	@Override
	public Path toAbsolutePath() {
		if (isAbsolute())
			return this;
		// FIXME it doesn't seem right
		return newInstance(getSegments(), true);
	}

	@Override
	public Path toRealPath(LinkOption... options) throws IOException {
		return this;
	}

	@Override
	public File toFile() {
		throw new UnsupportedOperationException();
	}

	/*
	 * PATH OPERATIONS
	 */
	public final Path resolveSibling(Path other) {
		if (other == null)
			throw new NullPointerException();
		Path parent = getParent();
		return (parent == null) ? other : parent.resolve(other);
	}

	@Override
	public final Path resolveSibling(String other) {
		return resolveSibling(getFileSystem().getPath(other));
	}

	public final Path resolve(String other) {
		return resolve(retrieve(other));
	}

	public boolean startsWith(Path other) {
		return toString().startsWith(other.toString());
	}

	public boolean endsWith(Path other) {
		return toString().endsWith(other.toString());
	}

	@Override
	public Path normalize() {
		// always normalized
		return this;
	}

	@Override
	public final Iterator<Path> iterator() {
		return new Iterator<Path>() {
			private int i = 0;

			@Override
			public boolean hasNext() {
				return (i < getNameCount());
			}

			@Override
			public Path next() {
				if (i < getNameCount()) {
					Path result = getName(i);
					i++;
					return result;
				} else {
					throw new NoSuchElementException();
				}
			}

			@Override
			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}

	@Override
	public int compareTo(Path other) {
		return toString().compareTo(other.toString());
	}

	public Path resolve(Path other) {
		AbstractFsPath<?, ?> otherPath = (AbstractFsPath<?, ?>) other;
		if (otherPath.isAbsolute())
			return other;
		String[] newPath;
		if (isRoot()) {
			newPath = new String[otherPath.segments.length];
			System.arraycopy(otherPath.segments, 0, newPath, 0, otherPath.segments.length);
		} else {
			newPath = new String[segments.length + otherPath.segments.length];
			System.arraycopy(segments, 0, newPath, 0, segments.length);
			System.arraycopy(otherPath.segments, 0, newPath, segments.length, otherPath.segments.length);
		}
		if (!absolute)
			return newInstance(newPath, absolute);
		else {
			return newInstance(toString(newPath));
		}
	}

	public Path relativize(Path other) {
		if (equals(other))
			return newInstance("");
		if (other.toString().startsWith(this.toString())) {
			String p1 = toString();
			String p2 = other.toString();
			String relative = p2.substring(p1.length(), p2.length());
			if (relative.charAt(0) == '/')
				relative = relative.substring(1);
			return newInstance(relative);
		}
		throw new IllegalArgumentException(other + " cannot be relativized against " + this);
	}

	/*
	 * FACTORIES
	 */
	protected abstract AbstractFsPath<FS, ST> newInstance(String path);

	protected abstract AbstractFsPath<FS, ST> newInstance(String[] segments, boolean absolute);

	/*
	 * CUSTOMISATIONS
	 */
	protected String toStringRoot() {
		return separator;
	}

	protected String cleanUpSegment(String segment) {
		return segment;
	}

	protected boolean isRoot() {
		return segments == null;
	}

	protected boolean isEmpty() {
		return segments.length == 1 && "".equals(segments[0]);
	}

	/*
	 * PATH OPERATIONS
	 */
	public AbstractFsPath<FS, ST> getRoot() {
		return newInstance(toStringRoot());
	}

	public AbstractFsPath<FS, ST> getParent() {
		if (isRoot())
			return null;
		// FIXME empty path?
		if (segments.length == 1)// first level
			return newInstance(toStringRoot());
		String[] parentPath = Arrays.copyOfRange(segments, 0, segments.length - 1);
		if (!absolute)
			return newInstance(parentPath, absolute);
		else
			return newInstance(toString(parentPath));
	}

	public AbstractFsPath<FS, ST> getFileName() {
		if (isRoot())
			return null;
		return newInstance(segments[segments.length - 1]);
	}

	public int getNameCount() {
		if (isRoot())
			return 0;
		return segments.length;
	}

	public AbstractFsPath<FS, ST> getName(int index) {
		if (isRoot())
			return null;
		return newInstance(segments[index]);
	}

	public AbstractFsPath<FS, ST> subpath(int beginIndex, int endIndex) {
		if (isRoot())
			return null;
		String[] parentPath = Arrays.copyOfRange(segments, beginIndex, endIndex);
		return newInstance(parentPath, false);
	}

	public boolean startsWith(String other) {
		return toString().startsWith(other);
	}

	public boolean endsWith(String other) {
		return toString().endsWith(other);
	}

	/*
	 * UTILITIES
	 */
	protected String toString(String[] path) {
		if (isRoot())
			return toStringRoot();
		StringBuilder sb = new StringBuilder();
		if (isAbsolute())
			sb.append(separator);
		for (int i = 0; i < path.length; i++) {
			if (i != 0)
				sb.append(separator);
			sb.append(path[i]);
		}
		return sb.toString();
	}

	@Override
	public String toString() {
		return toString(segments);
	}

	@Override
	public int hashCode() {
		return hashCode;
	}

	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof AbstractFsPath))
			return false;
		AbstractFsPath<?, ?> other = (AbstractFsPath<?, ?>) obj;

		if (isRoot()) {// root
			if (other.isRoot())// root
				return true;
			else
				return false;
		} else {
			if (other.isRoot())// root
				return false;
		}
		// non root
		if (segments.length != other.segments.length)
			return false;
		for (int i = 0; i < segments.length; i++) {
			if (!segments[i].equals(other.segments[i]))
				return false;
		}
		return true;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		return newInstance(toString());
	}

	/*
	 * GETTERS / SETTERS
	 */
	protected String[] getSegments() {
		return segments;
	}

	protected String getSeparator() {
		return separator;
	}

	/*
	 * UNSUPPORTED
	 */
	@Override
	public WatchKey register(WatchService watcher, Kind<?>[] events, Modifier... modifiers) throws IOException {
		throw new UnsupportedOperationException();
	}

	@Override
	public WatchKey register(WatchService watcher, Kind<?>... events) throws IOException {
		throw new UnsupportedOperationException();
	}

}