/**
	Contains routines for high level path handling.

	Copyright: © 2012-2021 Sönke Ludwig
	License: Subject to the terms of the MIT license, as written in the included LICENSE.txt file.
	Authors: Sönke Ludwig
*/
module vibe.core.path;

import std.algorithm.searching : commonPrefix, endsWith, startsWith;
import std.algorithm.comparison : equal, min;
import std.algorithm.iteration : map;
import std.exception : enforce;
import std.range : empty, front, popFront, popFrontExactly, takeExactly;
import std.range.primitives : ElementType, isInputRange, isOutputRange, isForwardRange, save;
import std.traits : isArray, isInstanceOf, isSomeChar;
import std.utf : byChar;


/** Computes the relative path from `base_path` to this path.

	Params:
		path = The destination path
		base_path = The path from which the relative path starts

	See_also: `relativeToWeb`
*/
Path relativeTo(Path)(Path path, Path base_path) @safe
	if (isInstanceOf!(GenericPath, Path))
{
	import std.array : array, replicate;
	import std.range : chain, drop, take;

	assert(base_path.absolute, "Base path must be absolute for relativeTo.");
	assert(path.absolute, "Path must be absolute for relativeTo.");

	if (is(Path == WindowsPath)) { // FIXME: this shouldn't be a special case here!
		bool samePrefix(size_t n)
		{
			return path.bySegment2.map!(n => n.encodedName).take(n).equal(base_path.bySegment2.map!(n => n.encodedName).take(n));
		}
		// a path such as ..\C:\windows is not valid, so force the path to stay absolute in this case
		auto pref = path.bySegment2;
		if (!pref.empty && pref.front.encodedName == "") {
			pref.popFront();
			if (!pref.empty) {
				// different drive?
				if (pref.front.encodedName.endsWith(':') && !samePrefix(2))
					return path;
				// different UNC path?
				if (pref.front.encodedName == "" && !samePrefix(4))
					return path;
			}
		}
	}

	auto nodes = path.bySegment2;
	auto base_nodes = base_path.bySegment2;

	// skip and count common prefix
	size_t base = 0;
	while (!nodes.empty && !base_nodes.empty && equal(nodes.front.name, base_nodes.front.name)) {
		nodes.popFront();
		base_nodes.popFront();
		base++;
	}

	enum up = Path.Segment2("..", Path.defaultSeparator);
	auto ret = Path(base_nodes.map!(p => up).chain(nodes));
	if (path.endsWithSlash) {
		if (ret.empty) return Path.fromTrustedString("." ~ path.toString()[$-1]);
		else ret.endsWithSlash = true;
	}
	return ret;
}

///
unittest {
	import std.array : array;
	import std.conv : to;
	assert(PosixPath("/some/path").relativeTo(PosixPath("/")) == PosixPath("some/path"));
	assert(PosixPath("/some/path/").relativeTo(PosixPath("/some/other/path/")) == PosixPath("../../path/"));
	assert(PosixPath("/some/path/").relativeTo(PosixPath("/some/other/path")) == PosixPath("../../path/"));

	assert(WindowsPath("C:\\some\\path").relativeTo(WindowsPath("C:\\")) == WindowsPath("some\\path"));
	assert(WindowsPath("C:\\some\\path\\").relativeTo(WindowsPath("C:\\some\\other\\path/")) == WindowsPath("..\\..\\path\\"));
	assert(WindowsPath("C:\\some\\path\\").relativeTo(WindowsPath("C:\\some\\other\\path")) == WindowsPath("..\\..\\path\\"));

	assert(WindowsPath("\\\\server\\share\\some\\path").relativeTo(WindowsPath("\\\\server\\share\\")) == WindowsPath("some\\path"));
	assert(WindowsPath("\\\\server\\share\\some\\path\\").relativeTo(WindowsPath("\\\\server\\share\\some\\other\\path/")) == WindowsPath("..\\..\\path\\"));
	assert(WindowsPath("\\\\server\\share\\some\\path\\").relativeTo(WindowsPath("\\\\server\\share\\some\\other\\path")) == WindowsPath("..\\..\\path\\"));

	assert(WindowsPath("C:\\some\\path").relativeTo(WindowsPath("D:\\")) == WindowsPath("C:\\some\\path"));
	assert(WindowsPath("C:\\some\\path\\").relativeTo(WindowsPath("\\\\server\\share")) == WindowsPath("C:\\some\\path\\"));
	assert(WindowsPath("\\\\server\\some\\path\\").relativeTo(WindowsPath("C:\\some\\other\\path")) == WindowsPath("\\\\server\\some\\path\\"));
	assert(WindowsPath("\\\\server\\some\\path\\").relativeTo(WindowsPath("\\\\otherserver\\path")) == WindowsPath("\\\\server\\some\\path\\"));
	assert(WindowsPath("\\some\\path\\").relativeTo(WindowsPath("\\other\\path")) == WindowsPath("..\\..\\some\\path\\"));

	assert(WindowsPath("\\\\server\\share\\path1").relativeTo(WindowsPath("\\\\server\\share\\path2")) == WindowsPath("..\\path1"));
	assert(WindowsPath("\\\\server\\share\\path1").relativeTo(WindowsPath("\\\\server\\share2\\path2")) == WindowsPath("\\\\server\\share\\path1"));
	assert(WindowsPath("\\\\server\\share\\path1").relativeTo(WindowsPath("\\\\server2\\share2\\path2")) == WindowsPath("\\\\server\\share\\path1"));
}

unittest {
	{
		auto parentpath = "/path/to/parent";
		auto parentpathp = PosixPath(parentpath);
		auto subpath = "/path/to/parent/sub/";
		auto subpathp = PosixPath(subpath);
		auto subpath_rel = "sub/";
		assert(subpathp.relativeTo(parentpathp).toString() == subpath_rel);
		auto subfile = "/path/to/parent/child";
		auto subfilep = PosixPath(subfile);
		auto subfile_rel = "child";
		assert(subfilep.relativeTo(parentpathp).toString() == subfile_rel);
	}

	{ // relative paths across Windows devices are not allowed
		auto p1 = WindowsPath("\\\\server\\share"); assert(p1.absolute);
		auto p2 = WindowsPath("\\\\server\\othershare"); assert(p2.absolute);
		auto p3 = WindowsPath("\\\\otherserver\\share"); assert(p3.absolute);
		auto p4 = WindowsPath("C:\\somepath"); assert(p4.absolute);
		auto p5 = WindowsPath("C:\\someotherpath"); assert(p5.absolute);
		auto p6 = WindowsPath("D:\\somepath"); assert(p6.absolute);
		auto p7 = WindowsPath("\\\\server\\share\\path"); assert(p7.absolute);
		auto p8 = WindowsPath("\\\\server\\share\\otherpath"); assert(p8.absolute);
		assert(p4.relativeTo(p5) == WindowsPath("..\\somepath"));
		assert(p4.relativeTo(p6) == WindowsPath("C:\\somepath"));
		assert(p4.relativeTo(p1) == WindowsPath("C:\\somepath"));
		assert(p1.relativeTo(p2) == WindowsPath("\\\\server\\share"));
		assert(p1.relativeTo(p3) == WindowsPath("\\\\server\\share"));
		assert(p1.relativeTo(p4) == WindowsPath("\\\\server\\share"));
		assert(p7.relativeTo(p1) == WindowsPath("path"));
		assert(p7.relativeTo(p8) == WindowsPath("..\\path"));
	}

	{ // relative path, trailing slash
		auto p1 = PosixPath("/some/path");
		auto p2 = PosixPath("/some/path/");
		assert(p1.relativeTo(p1).toString() == "");
		assert(p1.relativeTo(p2).toString() == "");
		assert(p2.relativeTo(p2).toString() == "./");
	}
}

nothrow unittest {
	auto p1 = PosixPath.fromTrustedString("/foo/bar/baz");
	auto p2 = PosixPath.fromTrustedString("/foo/baz/bam");
	assert(p2.relativeTo(p1).toString == "../../baz/bam");
}


/** Computes the relative path to this path from `base_path` using web path rules.

	The difference to `relativeTo` is that a path not ending in a slash
	will not be considered as a path to a directory and the parent path
	will instead be used.

	Params:
		path = The destination path
		base_path = The path from which the relative path starts

	See_also: `relativeTo`
*/
Path relativeToWeb(Path)(Path path, Path base_path) @safe
	if (isInstanceOf!(GenericPath, Path))
{
	if (!base_path.endsWithSlash) {
		assert(base_path.absolute, "Base path must be absolute for relativeToWeb.");
		if (base_path.hasParentPath) base_path = base_path.parentPath;
		else base_path = Path("/");
		assert(base_path.absolute);
	}
	return path.relativeTo(base_path);
}

///
/+unittest {
	assert(InetPath("/some/path").relativeToWeb(InetPath("/")) == InetPath("some/path"));
	assert(InetPath("/some/path/").relativeToWeb(InetPath("/some/other/path/")) == InetPath("../../path/"));
	assert(InetPath("/some/path/").relativeToWeb(InetPath("/some/other/path")) == InetPath("../path/"));
}+/


/** Converts a path to its system native string representation.
*/
string toNativeString(P)(P path)
{
	return (cast(NativePath)path).toString();
}


/// Represents a path on Windows operating systems.
alias WindowsPath = GenericPath!WindowsPathFormat;

/// Represents a path on Unix/Posix systems.
alias PosixPath = GenericPath!PosixPathFormat;

/// Represents a path as part of an URI.
alias InetPath = GenericPath!InetPathFormat;

/// The path type native to the target operating system.
version (Windows) alias NativePath = WindowsPath;
else alias NativePath = PosixPath;

deprecated("Use NativePath or one the specific path types instead.")
alias Path = NativePath;
deprecated("Use NativePath.Segment or one the specific path types instead.")
alias PathEntry = Path.Segment;

/// Provides a common interface to operate on paths of various kinds.
struct GenericPath(F) {
@safe:
	alias Format = F;

	/** A single path segment.
	*/
	static struct Segment {
		@safe:

		private {
			string m_name;
			char m_separator = 0;
		}

		/** Constructs a new path segment including an optional trailing
			separator.

			Params:
				name = The raw (unencoded) name of the path segment
				separator = Optional trailing path separator (e.g. `'/'`)

			Throws:
				A `PathValidationException` is thrown if the name contains
				characters that are invalid for the path type. In particular,
				any path separator characters may not be part of the name.
		*/
		this(string name, char separator = '\0')
		{
			import std.algorithm.searching : any;

			enforce!PathValidationException(separator == '\0' || Format.isSeparator(separator),
				"Invalid path separator.");
			auto err = Format.validateDecodedSegment(name);
			enforce!PathValidationException(err is null, err);

			m_name = name;
			m_separator = separator;
		}

		/** Constructs a path segment without performing validation.

			Note that in debug builds, there are still assertions in place
			that verify that the provided values are valid.

			Params:
				name = The raw (unencoded) name of the path segment
				separator = Optional trailing path separator (e.g. `'/'`)
		*/
		static Segment fromTrustedString(string name, char separator = '\0')
		nothrow @nogc pure {
			import std.algorithm.searching : any;
			assert(separator == '\0' || Format.isSeparator(separator));
			assert(Format.validateDecodedSegment(name) is null, "Invalid path segment.");

			Segment ret;
			ret.m_name = name;
			ret.m_separator = separator;
			return ret;
		}

		deprecated("Use the constructor instead.")
		static Segment validateFilename(string name)
		{
			return Segment(name);
		}

		/// The (file/directory) name of the path segment.
		@property string name() const nothrow @nogc { return m_name; }
		/// The trailing separator (e.g. `'/'`) or `'\0'`.
		@property char separator() const nothrow @nogc { return m_separator; }
		/// ditto
		@property void separator(char ch) {
			enforce!PathValidationException(ch == '\0' || Format.isSeparator(ch),
				"Character is not a valid path separator.");
			m_separator = ch;
		}
		/// Returns `true` $(I iff) the segment has a trailing path separator.
		@property bool hasSeparator() const nothrow @nogc { return m_separator != '\0'; }

		deprecated("Use .name instead.")
		string toString() const nothrow @nogc { return m_name; }

		/** Converts the segment to another path type.

			The segment name will be re-validated during the conversion. The
			separator, if any, will be adopted or replaced by the default
			separator of the target path type.

			Throws:
				A `PathValidationException` is thrown if the segment name cannot
				be represented in the target path format.
		*/
		GenericPath!F.Segment opCast(T : GenericPath!F.Segment, F)()
		{
			char dsep = '\0';
			if (m_separator) {
				if (F.isSeparator(m_separator)) dsep = m_separator;
				else dsep = F.defaultSeparator;
			}
			return GenericPath!F.Segment(m_name, dsep);
		}

		/// Compares two path segment names
		bool opEquals(Segment other) const nothrow @nogc { return this.name == other.name && this.hasSeparator == other.hasSeparator; }
		/// ditto
		bool opEquals(string name) const nothrow @nogc { return this.name == name; }
	}

	/** Represents a path as an forward range of `Segment`s.
	*/
	static struct PathRange {
		import std.traits : ReturnType;

		private {
			string m_path;
			Segment m_front;
		}

		private this(string path)
		{
			m_path = path;
			if (m_path.length) {
				auto ap = Format.getAbsolutePrefix(m_path);
				if (ap.length && !Format.isSeparator(ap[0]))
					m_front = Segment.fromTrustedString(null, '/');
				else readFront();
			}
		}

		@property bool empty() const nothrow @nogc { return m_path.length == 0 && m_front == Segment.init; }

		@property PathRange save() { return this; }

		@property Segment front() { return m_front; }

		void popFront()
		nothrow {
			assert(m_front != Segment.init);
			if (m_path.length) readFront();
			else m_front = Segment.init;
		}

		private void readFront()
		nothrow {
			import std.array : array;

			auto n = Format.getFrontNode(m_path);
			m_path = m_path[n.length .. $];

			char sep = '\0';
			if (Format.isSeparator(n[$-1])) {
				sep = n[$-1];
				n = n[0 .. $-1];
			}
			static if (is(typeof(Format.decodeSingleSegment(n)) == string))
				string ndec = Format.decodeSingleSegment(n);
			else
				string ndec = Format.decodeSingleSegment(n).array;
			m_front = Segment.fromTrustedString(ndec, sep);
			assert(m_front != Segment.init);
		}
	}

	/** A single path segment.
	*/
	static struct Segment2 {
		@safe:

		private {
			string m_encodedName;
			char m_separator = 0;
		}

		/** Constructs a new path segment including an optional trailing
			separator.

			Params:
				name = The raw (unencoded) name of the path segment
				separator = Optional trailing path separator (e.g. `'/'`)

			Throws:
				A `PathValidationException` is thrown if the name contains
				characters that are invalid for the path type. In particular,
				any path separator characters may not be part of the name.
		*/
		this(string name, char separator = '\0')
		{
			import std.algorithm.searching : any;

			enforce!PathValidationException(separator == '\0' || Format.isSeparator(separator),
				"Invalid path separator.");
			auto err = Format.validateDecodedSegment(name);
			enforce!PathValidationException(err is null, err);

			m_encodedName = Format.encodeSegment(name);
			m_separator = separator;
		}

		/** Constructs a path segment without performing validation.

			Note that in debug builds, there are still assertions in place
			that verify that the provided values are valid.

			Params:
				name = The raw (unencoded) name of the path segment
				separator = Optional trailing path separator (e.g. `'/'`)
		*/
		static Segment2 fromTrustedString(string name, char separator = '\0')
		nothrow pure {
			import std.algorithm.searching : any;
			assert(separator == '\0' || Format.isSeparator(separator));
			assert(Format.validateDecodedSegment(name) is null, "Invalid path segment.");
			return fromTrustedEncodedString(Format.encodeSegment(name), separator);
		}

		/** Constructs a path segment without performing validation.

			Note that in debug builds, there are still assertions in place
			that verify that the provided values are valid.

			Params:
				encoded_name = The encoded name of the path segment
				separator = Optional trailing path separator (e.g. `'/'`)
		*/
		static Segment2 fromTrustedEncodedString(string encoded_name, char separator = '\0')
		nothrow @nogc pure {
			import std.algorithm.searching : any;
			import std.utf : byCodeUnit;

			assert(separator == '\0' || Format.isSeparator(separator));
			assert(!encoded_name.byCodeUnit.any!(c => Format.isSeparator(c)));
			assert(Format.validatePath(encoded_name) is null, "Invalid path segment.");

			Segment2 ret;
			ret.m_encodedName = encoded_name;
			ret.m_separator = separator;
			return ret;
		}

		/** The (file/directory) name of the path segment.

			Note: Depending on the path type, this may return a generic range
			type instead of `string`. Use `name.to!string` in that
			case if you need an actual `string`.
		*/
		@property auto name() const nothrow @nogc { return Format.decodeSingleSegment(m_encodedName); }
		/// The encoded representation of the path segment name
		@property string encodedName() const nothrow @nogc { return m_encodedName; }
		/// The trailing separator (e.g. `'/'`) or `'\0'`.
		@property char separator() const nothrow @nogc { return m_separator; }
		/// ditto
		@property void separator(char ch) {
			enforce!PathValidationException(ch == '\0' || Format.isSeparator(ch),
				"Character is not a valid path separator.");
			m_separator = ch;
		}
		/// Returns `true` $(I iff) the segment has a trailing path separator.
		@property bool hasSeparator() const nothrow @nogc { return m_separator != '\0'; }


		/** The extension part of the file name.

			If the file name contains an extension, this returns a forward range
			with the extension including the leading dot. Otherwise an empty
			range is returned.

			See_also: `stripExtension`
		*/
		@property auto extension()
		const nothrow @nogc {
			return .extension(this.name);
		}

		///
		unittest {
			assert(PosixPath("/foo/bar.txt").head2.extension.equal(".txt"));
			assert(PosixPath("/foo/bar").head2.extension.equal(""));
			assert(PosixPath("/foo/.bar").head2.extension.equal(""));
			assert(PosixPath("/foo/.bar.txt").head2.extension.equal(".txt"));
		}


		/** Returns the file base name, excluding the extension.

			See_also: `extension`
		*/
		@property auto withoutExtension()
		const nothrow @nogc {
			return .stripExtension(this.name);
		}

		///
		unittest {
			assert(PosixPath("/foo/bar.txt").head2.withoutExtension.equal("bar"));
			assert(PosixPath("/foo/bar").head2.withoutExtension.equal("bar"));
			assert(PosixPath("/foo/.bar").head2.withoutExtension.equal(".bar"));
			assert(PosixPath("/foo/.bar.txt").head2.withoutExtension.equal(".bar"));
		}


		/** Converts the segment to another path type.

			The segment name will be re-validated during the conversion. The
			separator, if any, will be adopted or replaced by the default
			separator of the target path type.

			Throws:
				A `PathValidationException` is thrown if the segment name cannot
				be represented in the target path format.
		*/
		GenericPath!F.Segment2 opCast(T : GenericPath!F.Segment2, F)()
		{
			import std.array : array;

			char dsep = '\0';
			if (m_separator) {
				if (F.isSeparator(m_separator)) dsep = m_separator;
				else dsep = F.defaultSeparator;
			}
			static if (is(typeof(this.name) == string))
				string n = this.name;
			else
				string n = this.name.array;
			return GenericPath!F.Segment2(n, dsep);
		}

		/// Compares two path segment names
		bool opEquals(Segment2 other)
		const nothrow @nogc {
			try return equal(this.name, other.name) && this.hasSeparator == other.hasSeparator;
			catch (Exception e) assert(false, e.msg);
		}
		/// ditto
		bool opEquals(string name)
		const nothrow @nogc {
			import std.utf : byCodeUnit;
			try return equal(this.name, name.byCodeUnit);
			catch (Exception e) assert(false, e.msg);
		}
	}

	private {
		string m_path;
	}

	/// The default path segment separator character.
	enum char defaultSeparator = Format.defaultSeparator;

	/** Constructs a path from its string representation.

		Throws:
			A `PathValidationException` is thrown if the given path string
			is not valid.
	*/
	this(string p)
	{
		auto err = Format.validatePath(p);
		enforce!PathValidationException(err is null, err);
		m_path = p;
	}

	/** Constructs a path from a single path segment.

		This is equivalent to calling the range based constructor with a
		single-element range.
	*/
	this(Segment segment)
	{
		import std.range : only;
		this(only(segment));
	}
	/// ditto
	this(Segment2 segment)
	{
		import std.range : only;
		this(only(segment));
	}

	/** Constructs a path from an input range of `Segment`s.

		Throws:
			Since path segments are pre-validated, this constructor does not
			throw an exception.
	*/
	this(R)(R segments)
		if (isInputRange!R && is(ElementType!R : Segment))
	{
		import std.array : appender;
		auto dst = appender!string;
		Format.toString(segments, dst);
		m_path = dst.data;
	}
	/// ditto
	this(R)(R segments)
		if (isInputRange!R && is(ElementType!R : Segment2))
	{
		import std.array : appender;
		auto dst = appender!string;
		Format.toString(segments, dst);
		m_path = dst.data;
	}

	/** Constructs a path from its string representation.

		This is equivalent to calling the string based constructor.
	*/
	static GenericPath fromString(string p)
	{
		return GenericPath(p);
	}

	/** Constructs a path from its string representation, skipping the
		validation.

		Note that it is required to pass a pre-validated path string
		to this function. Debug builds will enforce this with an assertion.
	*/
	static GenericPath fromTrustedString(string p)
	nothrow @nogc {
		assert(Format.validatePath(p) is null, "Invalid trusted path.");
		GenericPath ret;
		ret.m_path = p;
		return ret;
	}

	/// Tests if a certain character is a path segment separator.
	static bool isSeparator(dchar ch) { return ch < 0x80 && Format.isSeparator(cast(char)ch); }

	/// Tests if the path is represented by an empty string.
	@property bool empty() const nothrow @nogc { return m_path.length == 0; }

	/// Tests if the path is absolute.
	@property bool absolute() const nothrow @nogc { return Format.getAbsolutePrefix(m_path).length > 0; }

	/// Determines whether the path ends with a path separator (i.e. represents a folder specifically).
	@property bool endsWithSlash() const nothrow @nogc { return m_path.length > 0 && Format.isSeparator(m_path[$-1]); }
	/// ditto
	@property void endsWithSlash(bool v)
	nothrow {
		bool ews = this.endsWithSlash;
		if (!ews && v) m_path ~= Format.defaultSeparator;
		else if (ews && !v) m_path = m_path[0 .. $-1]; // FIXME?: "/test//" -> "/test/"
	}

	/// Iterates over the path by `Segment`.
	@property PathRange bySegment() const { return PathRange(m_path); }


	/** Iterates over the individual segments of the path.

		Returns a forward range of `Segment2`s.
	*/
	@property auto bySegment2()
	const {
		static struct R {
			import std.traits : ReturnType;

			private {
				string m_path;
				Segment2 m_front;
			}

			private this(string path)
			{
				m_path = path;
				if (m_path.length) {
					auto ap = Format.getAbsolutePrefix(m_path);
					if (ap.length && !Format.isSeparator(ap[0]))
						m_front = Segment2.fromTrustedEncodedString(null, '/');
					else readFront();
				}
			}

			@property bool empty() const nothrow @nogc { return m_path.length == 0 && m_front == Segment2.init; }

			@property R save() { return this; }

			@property Segment2 front() { return m_front; }

			void popFront()
			nothrow {
				assert(m_front != Segment2.init);
				if (m_path.length) readFront();
				else m_front = Segment2.init;
			}

			private void readFront()
			{
				auto n = Format.getFrontNode(m_path);
				m_path = m_path[n.length .. $];

				char sep = '\0';
				if (Format.isSeparator(n[$-1])) {
					sep = n[$-1];
					n = n[0 .. $-1];
				}
				m_front = Segment2.fromTrustedEncodedString(n, sep);
				assert(m_front != Segment2.init);
			}
		}

		return R(m_path);
	}

	///
	unittest {
		InetPath p = "foo/bar/baz";
		assert(p.bySegment2.equal([
			InetPath.Segment2("foo", '/'),
			InetPath.Segment2("bar", '/'),
			InetPath.Segment2("baz")
		]));
	}


	/** Iterates over the path by segment, each time returning the sub path
		leading to that segment.
	*/
	@property auto byPrefix()
	const nothrow @nogc {
		static struct R {
			import std.traits : ReturnType;

			private {
				string m_path;
				string m_remainder;
			}

			private this(string path)
			{
				m_path = path;
				m_remainder = path;
				if (m_path.length) {
					auto ap = Format.getAbsolutePrefix(m_path);
					if (ap.length && !Format.isSeparator(ap[0]))
						m_remainder = m_remainder[ap.length .. $];
					else popFront();
				}
			}

			@property bool empty() const nothrow @nogc
			{
				return m_path.length == 0;
			}

			@property R save() { return this; }

			@property GenericPath front()
			{
				return GenericPath.fromTrustedString(m_path[0 .. $-m_remainder.length]);
			}

			void popFront()
			nothrow {
				assert(m_remainder.length > 0 || m_path.length > 0);
				if (m_remainder.length) readFront();
				else m_path = "";
			}

			private void readFront()
			{
				auto n = Format.getFrontNode(m_remainder);
				m_remainder = m_remainder[n.length .. $];
			}
		}

		return R(m_path);
	}

	///
	unittest {
		assert(InetPath("foo/bar/baz").byPrefix
			.equal([
				InetPath("foo/"),
				InetPath("foo/bar/"),
				InetPath("foo/bar/baz")
			]));

		assert(InetPath("/foo/bar").byPrefix
			.equal([
				InetPath("/"),
				InetPath("/foo/"),
				InetPath("/foo/bar"),
			]));
	}


	/// Returns the trailing segment of the path.
	@property Segment head()
	const {
		import std.array : array;

		auto n = Format.getBackNode(m_path);
		char sep = '\0';
		if (n.length > 0 && Format.isSeparator(n[$-1])) {
			sep = n[$-1];
			n = n[0 .. $-1];
		}

		static if (is(typeof(Format.decodeSingleSegment(n)) == string))
			string ndec = Format.decodeSingleSegment(n);
		else
			string ndec = Format.decodeSingleSegment(n).array;

		return Segment.fromTrustedString(ndec, sep);
	}

	/// Returns the trailing segment of the path.
	@property Segment2 head2()
	const @nogc {
		auto n = Format.getBackNode(m_path);
		char sep = '\0';
		if (n.length > 0 && Format.isSeparator(n[$-1])) {
			sep = n[$-1];
			n = n[0 .. $-1];
		}
		return Segment2.fromTrustedEncodedString(n, sep);
	}

	/** Determines if the `parentPath` property is valid.
	*/
	@property bool hasParentPath()
	const @nogc {
		auto b = Format.getBackNode(m_path);
		return b.length < m_path.length;
	}

	/** Returns a prefix of this path, where the last segment has been dropped.

		Throws:
			An `Exception` is thrown if this path has no parent path. Use
			`hasParentPath` to test this upfront.
	*/
	@property GenericPath parentPath()
	const @nogc {
		auto b = Format.getBackNode(m_path);
		static immutable Exception e = new Exception("Path has no parent path");
		if (b.length >= m_path.length) throw e;
		return GenericPath.fromTrustedString(m_path[0 .. $ - b.length]);
	}


	/** The extension part of the file name pointed to by the path.

		If the path is not empty and its head segment has  an extension, this
		returns a forward range with the extension including the leading dot.
		Otherwise an empty range is returned.

		See `Segment2.extension` for a full description.

		See_also: `Segment2.extension`, `Segment2.stripExtension`
	*/
	@property auto fileExtension()
	const nothrow @nogc {
		if (this.empty) return typeof(this.head2.extension).init;
		return this.head2.extension;
	}


	/** Returns the normalized form of the path.

		See `normalize` for a full description.
	*/
	@property GenericPath normalized()
	const {
		GenericPath ret = this;
		ret.normalize();
		return ret;
	}

	unittest {
		assert(PosixPath("foo/../bar").normalized == PosixPath("bar"));
		assert(PosixPath("foo//./bar/../baz").normalized == PosixPath("foo/baz"));
	}


	/** Removes any redundant path segments and replaces all separators by the
		default one.

		The resulting path representation is suitable for basic semantic
		comparison to other normalized paths.

		Note that there are still ways for different normalized paths to
		represent the same file. Examples of this are the tilde shortcut to the
		home directory on Unix and Linux operating systems, symbolic or hard
		links, and possibly environment variables are examples of this.

		Throws:
			Throws an `Exception` if an absolute path contains parent directory
			segments ("..") that lead to a path that is a parent path of the
			root path.
	*/
	void normalize()
	{
		import std.array : appender, join;

		Segment2[] newnodes;
		bool got_non_sep = false;
		foreach (n; this.bySegment2) {
			if (n.hasSeparator) n.separator = Format.defaultSeparator;
			if (!got_non_sep) {
				if (n.encodedName == "") newnodes ~= n;
				else got_non_sep = true;
			}
			switch (n.encodedName) {
				default: newnodes ~= n; break;
				case "", ".": break;
				case "..":
					enforce(!this.absolute || newnodes.length > 0, "Path goes below root node.");
					if (newnodes.length > 0 && newnodes[$-1].encodedName != "..") newnodes = newnodes[0 .. $-1];
					else newnodes ~= n;
					break;
			}
		}

		auto dst = appender!string;
		Format.toString(newnodes, dst);
		m_path = dst.data;
	}

	///
	unittest {
		auto path = WindowsPath("C:\\test/foo/./bar///../baz");
		path.normalize();
		assert(path.toString() == "C:\\test\\foo\\baz", path.toString());

		path = WindowsPath("foo/../../bar/");
		path.normalize();
		assert(path.toString() == "..\\bar\\");
	}

	/// Returns the string representation of the path.
	string toString() const nothrow @nogc { return m_path; }

	/// Computes a hash sum, enabling storage within associative arrays.
	size_t toHash() const nothrow @trusted
	{
		try return typeid(string).getHash(&m_path);
		catch (Exception e) assert(false, "getHash for string throws!?");
	}

	/** Compares two path objects.

		Note that the exact string representation of the two paths will be
		compared. To get a basic semantic comparison, the paths must be
		normalized first.
	*/
	bool opEquals(GenericPath other) const @nogc { return this.m_path == other.m_path; }

	/** Converts the path to a different path format.

		Throws:
			A `PathValidationException` will be thrown if the path is not
			representable in the requested path format. This can happen
			especially when converting Posix or Internet paths to windows paths,
			since Windows paths cannot contain a number of characters that the
			other representations can, in theory.
	*/
	P opCast(P)() const if (isInstanceOf!(.GenericPath, P)) {
		static if (is(P == GenericPath)) return this;
		else return P(this.bySegment2.map!(n => cast(P.Segment2)n));
	}

	/** Concatenates two paths.

		The right hand side must represent a relative path.
	*/
	GenericPath opBinary(string op : "~")(string subpath) const { return this ~ GenericPath(subpath); }
	/// ditto
	GenericPath opBinary(string op : "~")(Segment subpath) const { return this ~ GenericPath(subpath); }
	/// ditto
	GenericPath opBinary(string op : "~")(Segment2 subpath) const { return this ~ GenericPath(subpath); }
	/// ditto
	GenericPath opBinary(string op : "~", F)(GenericPath!F.Segment subpath) const { return this ~ cast(Segment)(subpath); }
	/// ditto
	GenericPath opBinary(string op : "~", F)(GenericPath!F.Segment2 subpath) const { return this ~ cast(Segment2)(subpath); }
	/// ditto
	GenericPath opBinary(string op : "~")(GenericPath subpath) const nothrow {
		assert(!subpath.absolute || m_path.length == 0, "Cannot append absolute path.");
		if (endsWithSlash || empty) return GenericPath.fromTrustedString(m_path ~ subpath.m_path);
		else return GenericPath.fromTrustedString(m_path ~ Format.defaultSeparator ~ subpath.m_path);
	}
	/// ditto
	GenericPath opBinary(string op : "~", F)(GenericPath!F subpath) const if (!is(F == Format)) { return this ~ cast(GenericPath)subpath; }
	/// ditto
	GenericPath opBinary(string op : "~", R)(R entries) const nothrow
		if (isInputRange!R && is(ElementType!R : Segment))
	{
		return this ~ GenericPath(entries);
	}
	/// ditto
	GenericPath opBinary(string op : "~", R)(R entries) const nothrow
		if (isInputRange!R && is(ElementType!R : Segment2))
	{
		return this ~ GenericPath(entries);
	}

	/// Appends a relative path to this path.
	void opOpAssign(string op : "~", T)(T op) { this = this ~ op; }

	/** Tests whether the given path is a prefix of this path.

		Any path separators will be ignored during the comparison.
	*/
	bool startsWith(GenericPath prefix)
	const nothrow {
		return bySegment2.map!(n => n.name).startsWith(prefix.bySegment2.map!(n => n.name));
	}
}

unittest {
	assert(PosixPath("hello/world").bySegment.equal([PosixPath.Segment("hello",'/'), PosixPath.Segment("world")]));
	assert(PosixPath("/hello/world/").bySegment.equal([PosixPath.Segment("",'/'), PosixPath.Segment("hello",'/'), PosixPath.Segment("world",'/')]));
	assert(PosixPath("hello\\world").bySegment.equal([PosixPath.Segment("hello\\world")]));
	assert(WindowsPath("hello/world").bySegment.equal([WindowsPath.Segment("hello",'/'), WindowsPath.Segment("world")]));
	assert(WindowsPath("/hello/world/").bySegment.equal([WindowsPath.Segment("",'/'), WindowsPath.Segment("hello",'/'), WindowsPath.Segment("world",'/')]));
	assert(WindowsPath("hello\\w/orld").bySegment.equal([WindowsPath.Segment("hello",'\\'), WindowsPath.Segment("w",'/'), WindowsPath.Segment("orld")]));
	assert(WindowsPath("hello/w\\orld").bySegment.equal([WindowsPath.Segment("hello",'/'), WindowsPath.Segment("w",'\\'), WindowsPath.Segment("orld")]));
}

unittest {
	assert(PosixPath("hello/world").bySegment2.equal([PosixPath.Segment2("hello",'/'), PosixPath.Segment2("world")]));
	assert(PosixPath("/hello/world/").bySegment2.equal([PosixPath.Segment2("",'/'), PosixPath.Segment2("hello",'/'), PosixPath.Segment2("world",'/')]));
	assert(PosixPath("hello\\world").bySegment2.equal([PosixPath.Segment2("hello\\world")]));
	assert(WindowsPath("hello/world").bySegment2.equal([WindowsPath.Segment2("hello",'/'), WindowsPath.Segment2("world")]));
	assert(WindowsPath("/hello/world/").bySegment2.equal([WindowsPath.Segment2("",'/'), WindowsPath.Segment2("hello",'/'), WindowsPath.Segment2("world",'/')]));
	assert(WindowsPath("hello\\w/orld").bySegment2.equal([WindowsPath.Segment2("hello",'\\'), WindowsPath.Segment2("w",'/'), WindowsPath.Segment2("orld")]));
	assert(WindowsPath("hello/w\\orld").bySegment2.equal([WindowsPath.Segment2("hello",'/'), WindowsPath.Segment2("w",'\\'), WindowsPath.Segment2("orld")]));

	assert(PosixPath("hello/world").byPrefix.equal([PosixPath("hello/"), PosixPath("hello/world")]));
	assert(PosixPath("/hello/world/").byPrefix.equal([PosixPath("/"), PosixPath("/hello/"), PosixPath("/hello/world/")]));
	assert(WindowsPath("C:\\Windows").byPrefix.equal([WindowsPath("C:\\"), WindowsPath("C:\\Windows")]));
}

unittest
{
	{
		auto unc = "\\\\server\\share\\path";
		auto uncp = WindowsPath(unc);
		assert(uncp.absolute);
		uncp.normalize();
		version(Windows) assert(uncp.toNativeString() == unc);
		assert(uncp.absolute);
		assert(!uncp.endsWithSlash);
	}

	{
		auto abspath = "/test/path/";
		auto abspathp = PosixPath(abspath);
		assert(abspathp.toString() == abspath);
		version(Windows) {} else assert(abspathp.toNativeString() == abspath);
		assert(abspathp.absolute);
		assert(abspathp.endsWithSlash);
		alias S = PosixPath.Segment;
		assert(abspathp.bySegment.equal([S("", '/'), S("test", '/'), S("path", '/')]));
	}

	{
		auto relpath = "test/path/";
		auto relpathp = PosixPath(relpath);
		assert(relpathp.toString() == relpath);
		version(Windows) assert(relpathp.toNativeString() == "test/path/");
		else assert(relpathp.toNativeString() == relpath);
		assert(!relpathp.absolute);
		assert(relpathp.endsWithSlash);
		alias S = PosixPath.Segment;
		assert(relpathp.bySegment.equal([S("test", '/'), S("path", '/')]));
	}

	{
		auto winpath = "C:\\windows\\test";
		auto winpathp = WindowsPath(winpath);
		assert(winpathp.toString() == "C:\\windows\\test");
		assert((cast(PosixPath)winpathp).toString() == "/C:/windows/test", (cast(PosixPath)winpathp).toString());
		version(Windows) assert(winpathp.toNativeString() == winpath);
		else assert(winpathp.toNativeString() == "/C:/windows/test");
		assert(winpathp.absolute);
		assert(!winpathp.endsWithSlash);
		alias S = WindowsPath.Segment;
		assert(winpathp.bySegment.equal([S("", '/'), S("C:", '\\'), S("windows", '\\'), S("test")]));
	}

	{
		auto dotpath = "/test/../test2/././x/y";
		auto dotpathp = PosixPath(dotpath);
		assert(dotpathp.toString() == "/test/../test2/././x/y");
		dotpathp.normalize();
		assert(dotpathp.toString() == "/test2/x/y", dotpathp.toString());
	}

	{
		auto dotpath = "/test/..////test2//./x/y";
		auto dotpathp = PosixPath(dotpath);
		assert(dotpathp.toString() == "/test/..////test2//./x/y");
		dotpathp.normalize();
		assert(dotpathp.toString() == "/test2/x/y");
	}

	assert(WindowsPath("C:\\Windows").absolute);
	assert((cast(InetPath)WindowsPath("C:\\Windows")).toString() == "/C:/Windows");
	assert((WindowsPath("C:\\Windows") ~ InetPath("test/this")).toString() == "C:\\Windows\\test/this");
	assert(InetPath("/C:/Windows").absolute);
	assert((cast(WindowsPath)InetPath("/C:/Windows")).toString() == "C:/Windows");
	assert((InetPath("/C:/Windows") ~ WindowsPath("test\\this")).toString() == "/C:/Windows/test/this");
	assert((InetPath("") ~ WindowsPath("foo\\bar")).toString() == "foo/bar");
	assert((cast(InetPath)WindowsPath("C:\\Windows\\")).toString() == "/C:/Windows/");

	assert(NativePath("").empty);

	assert(PosixPath("/") ~ NativePath("foo/bar") == PosixPath("/foo/bar"));
	assert(PosixPath("") ~ NativePath("foo/bar") == PosixPath("foo/bar"));
	assert(PosixPath("foo") ~ NativePath("bar") == PosixPath("foo/bar"));
	assert(PosixPath("foo/") ~ NativePath("bar") == PosixPath("foo/bar"));
}

unittest
{
	{
		auto unc = "\\\\server\\share\\path";
		auto uncp = WindowsPath(unc);
		assert(uncp.absolute);
		uncp.normalize();
		version(Windows) assert(uncp.toNativeString() == unc);
		assert(uncp.absolute);
		assert(!uncp.endsWithSlash);
	}

	{
		auto abspath = "/test/path/";
		auto abspathp = PosixPath(abspath);
		assert(abspathp.toString() == abspath);
		version(Windows) {} else assert(abspathp.toNativeString() == abspath);
		assert(abspathp.absolute);
		assert(abspathp.endsWithSlash);
		alias S = PosixPath.Segment2;
		assert(abspathp.bySegment2.equal([S("", '/'), S("test", '/'), S("path", '/')]));
	}

	{
		auto relpath = "test/path/";
		auto relpathp = PosixPath(relpath);
		assert(relpathp.toString() == relpath);
		version(Windows) assert(relpathp.toNativeString() == "test/path/");
		else assert(relpathp.toNativeString() == relpath);
		assert(!relpathp.absolute);
		assert(relpathp.endsWithSlash);
		alias S = PosixPath.Segment2;
		assert(relpathp.bySegment2.equal([S("test", '/'), S("path", '/')]));
	}

	{
		auto winpath = "C:\\windows\\test";
		auto winpathp = WindowsPath(winpath);
		assert(winpathp.toString() == "C:\\windows\\test");
		assert((cast(PosixPath)winpathp).toString() == "/C:/windows/test", (cast(PosixPath)winpathp).toString());
		version(Windows) assert(winpathp.toNativeString() == winpath);
		else assert(winpathp.toNativeString() == "/C:/windows/test");
		assert(winpathp.absolute);
		assert(!winpathp.endsWithSlash);
		alias S = WindowsPath.Segment2;
		assert(winpathp.bySegment2.equal([S("", '/'), S("C:", '\\'), S("windows", '\\'), S("test")]));
	}
}

@safe unittest {
	import std.array : appender;
	auto app = appender!(PosixPath[]);
	void test1(PosixPath p) { app.put(p); }
	void test2(PosixPath[] ps) { app.put(ps); }
	//void test3(const(PosixPath) p) { app.put(p); } // DMD issue 17251
	//void test4(const(PosixPath)[] ps) { app.put(ps); }
}

unittest {
	import std.exception : assertThrown, assertNotThrown;

	assertThrown!PathValidationException(WindowsPath.Segment("foo/bar"));
	assertThrown!PathValidationException(PosixPath.Segment("foo/bar"));
	assertNotThrown!PathValidationException(InetPath.Segment("foo/bar"));

	auto p = InetPath("/foo%2fbar/");
	assert(p.bySegment.equal([InetPath.Segment("",'/'), InetPath.Segment("foo/bar",'/')]));
	p ~= InetPath.Segment("baz/bam");
	assert(p.toString() == "/foo%2fbar/baz%2Fbam", p.toString);
}

unittest {
	import std.exception : assertThrown, assertNotThrown;

	assertThrown!PathValidationException(WindowsPath.Segment2("foo/bar"));
	assertThrown!PathValidationException(PosixPath.Segment2("foo/bar"));
	assertNotThrown!PathValidationException(InetPath.Segment2("foo/bar"));

	auto p = InetPath("/foo%2fbar/");
	import std.conv : to;
	assert(p.bySegment2.equal([InetPath.Segment2("",'/'), InetPath.Segment2("foo/bar",'/')]), p.bySegment2.to!string);
	p ~= InetPath.Segment2("baz/bam");
	assert(p.toString() == "/foo%2fbar/baz%2Fbam", p.toString);
}

unittest {
	assert(!PosixPath("").hasParentPath);
	assert(!PosixPath("/").hasParentPath);
	assert(!PosixPath("foo\\bar").hasParentPath);
	assert(PosixPath("foo/bar").parentPath.toString() == "foo/");
	assert(PosixPath("./foo").parentPath.toString() == "./");
	assert(PosixPath("./foo").parentPath.toString() == "./");

	assert(!WindowsPath("").hasParentPath);
	assert(!WindowsPath("/").hasParentPath);
	assert(WindowsPath("foo\\bar").parentPath.toString() == "foo\\");
	assert(WindowsPath("foo/bar").parentPath.toString() == "foo/");
	assert(WindowsPath("./foo").parentPath.toString() == "./");
	assert(WindowsPath("./foo").parentPath.toString() == "./");

	assert(!InetPath("").hasParentPath);
	assert(!InetPath("/").hasParentPath);
	assert(InetPath("foo/bar").parentPath.toString() == "foo/");
	assert(InetPath("foo/bar%2Fbaz").parentPath.toString() == "foo/");
	assert(InetPath("./foo").parentPath.toString() == "./");
	assert(InetPath("./foo").parentPath.toString() == "./");
}

unittest {
	assert(WindowsPath([WindowsPath.Segment("foo"), WindowsPath.Segment("bar")]).toString() == "foo\\bar");
}

unittest {
	assert(WindowsPath([WindowsPath.Segment2("foo"), WindowsPath.Segment2("bar")]).toString() == "foo\\bar");
}

/// Thrown when an invalid string representation of a path is detected.
class PathValidationException : Exception {
	this(string text, string file = __FILE__, size_t line = cast(size_t)__LINE__, Throwable next = null)
		pure nothrow @nogc @safe
	{
		super(text, file, line, next);
	}
}

/** Implements Windows path semantics.

	See_also: `WindowsPath`
*/
struct WindowsPathFormat {
	static void toString(I, O)(I segments, O dst)
		if (isInputRange!I && isOutputRange!(O, char))
	{
		char sep(char s) { return isSeparator(s) ? s : defaultSeparator; }

		if (segments.empty) return;

		if (segments.front.name == "" && segments.front.separator) {
			auto s = segments.front.separator;
			segments.popFront();
			if (segments.empty || !segments.front.name.endsWith(":"))
				dst.put(sep(s));
		}

		char lastsep = '\0';
		bool first = true;
		foreach (s; segments) {
			if (!first || lastsep) dst.put(sep(lastsep));
			else first = false;
			dst.put(s.name);
			lastsep = s.separator;
		}
		if (lastsep) dst.put(sep(lastsep));
	}

	unittest {
		import std.array : appender;
		struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }}
		string str(Segment[] segs...) { auto ret = appender!string; toString(segs, ret); return ret.data; }

		assert(str() == "");
		assert(str(Segment("",'/')) == "/");
		assert(str(Segment("",'/'), Segment("foo")) == "/foo");
		assert(str(Segment("",'\\')) == "\\");
		assert(str(Segment("foo",'/'), Segment("bar",'/')) == "foo/bar/");
		assert(str(Segment("",'/'), Segment("foo",'\0')) == "/foo");
		assert(str(Segment("",'\\'), Segment("foo",'\\')) == "\\foo\\");
		assert(str(Segment("f oo")) == "f oo");
		assert(str(Segment("",'\\'), Segment("C:")) == "C:");
		assert(str(Segment("",'\\'), Segment("C:", '/')) == "C:/");
		assert(str(Segment("foo",'\\'), Segment("C:")) == "foo\\C:");
		assert(str(Segment("foo"), Segment("bar")) == "foo\\bar");
	}

@safe nothrow pure:
	enum defaultSeparator = '\\';

	static bool isSeparator(dchar ch)
	@nogc {
		return ch == '\\' || ch == '/';
	}

	static string getAbsolutePrefix(string path)
	@nogc {
		if (!path.length) return null;

		if (isSeparator(path[0])) {
			return path[0 .. 1];
		}

		foreach (i; 1 .. path.length)
			if (isSeparator(path[i])) {
				if (path[i-1] == ':') return path[0 .. i+1];
				break;
			}

		return path[$-1] == ':' ? path : null;
	}

	unittest {
		assert(getAbsolutePrefix("test") == "");
		assert(getAbsolutePrefix("test/") == "");
		assert(getAbsolutePrefix("/test") == "/");
		assert(getAbsolutePrefix("\\test") == "\\");
		assert(getAbsolutePrefix("C:\\") == "C:\\");
		assert(getAbsolutePrefix("C:") == "C:");
		assert(getAbsolutePrefix("C:\\test") == "C:\\");
		assert(getAbsolutePrefix("C:\\test\\") == "C:\\");
		assert(getAbsolutePrefix("C:/") == "C:/");
		assert(getAbsolutePrefix("C:/test") == "C:/");
		assert(getAbsolutePrefix("C:/test/") == "C:/");
		assert(getAbsolutePrefix("\\\\server") == "\\");
		assert(getAbsolutePrefix("\\\\server\\") == "\\");
		assert(getAbsolutePrefix("\\\\.\\") == "\\");
		assert(getAbsolutePrefix("\\\\?\\") == "\\");
	}

	static string getFrontNode(string path)
	@nogc {
		foreach (i; 0 .. path.length)
			if (isSeparator(path[i]))
				return path[0 .. i+1];
		return path;
	}

	unittest {
		assert(getFrontNode("") == "");
		assert(getFrontNode("/bar") == "/");
		assert(getFrontNode("foo/bar") == "foo/");
		assert(getFrontNode("foo/") == "foo/");
		assert(getFrontNode("foo") == "foo");
		assert(getFrontNode("\\bar") == "\\");
		assert(getFrontNode("foo\\bar") == "foo\\");
		assert(getFrontNode("foo\\") == "foo\\");
	}

	static string getBackNode(string path)
	@nogc {
		if (!path.length) return path;
		foreach_reverse (i; 0 .. path.length-1)
			if (isSeparator(path[i]))
				return path[i+1 .. $];
		return path;
	}

	unittest {
		assert(getBackNode("") == "");
		assert(getBackNode("/bar") == "bar");
		assert(getBackNode("foo/bar") == "bar");
		assert(getBackNode("foo/") == "foo/");
		assert(getBackNode("foo") == "foo");
		assert(getBackNode("\\bar") == "bar");
		assert(getBackNode("foo\\bar") == "bar");
		assert(getBackNode("foo\\") == "foo\\");
	}

	deprecated("Use decodeSingleSegment instead.")
	static auto decodeSegment(S)(string segment)
	{
		static struct R {
			S[2] items;
			size_t i = items.length;
			this(S s) { i = 1; items[i] = s; }
			this(S a, S b) { i = 0; items[0] = a; items[1] = b; }
			@property ref S front() { return items[i]; }
			@property bool empty() const { return i >= items.length; }
			void popFront() { i++; }
		}

		assert(segment.length > 0, "Path segment string must not be empty.");

		char sep = '\0';
		if (!segment.length) return R(S.fromTrustedString(null));
		if (isSeparator(segment[$-1])) {
			sep = segment[$-1];
			segment = segment[0 .. $-1];
		}

		// output an absolute marker segment for "C:\" style absolute segments
		if (segment.length > 0 && segment[$-1] == ':')
			return R(S.fromTrustedString("", '/'), S.fromTrustedString(segment, sep));

		return R(S.fromTrustedString(segment, sep));
	}

	deprecated unittest {
		struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }}
		assert(decodeSegment!Segment("foo").equal([Segment("foo")]));
		assert(decodeSegment!Segment("foo/").equal([Segment("foo", '/')]));
		assert(decodeSegment!Segment("fo%20o\\").equal([Segment("fo%20o", '\\')]));
		assert(decodeSegment!Segment("C:\\").equal([Segment("",'/'), Segment("C:", '\\')]));
		assert(decodeSegment!Segment("bar:\\").equal([Segment("",'/'), Segment("bar:", '\\')]));
	}

	static string decodeSingleSegment(string segment)
	@nogc {
		assert(segment.length == 0 || segment[$-1] != '/');
		return segment;
	}

	unittest {
		struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }}
		assert(decodeSingleSegment("foo") == "foo");
		assert(decodeSingleSegment("fo%20o") == "fo%20o");
		assert(decodeSingleSegment("C:") == "C:");
		assert(decodeSingleSegment("bar:") == "bar:");
	}

	static string validatePath(string path)
	@nogc {
		import std.algorithm.comparison : among;

		// skip UNC prefix
		if (path.startsWith("\\\\")) {
			path = path[2 .. $];
			while (path.length && !isSeparator(path[0])) {
				if (path[0] < 32 || path[0].among('<', '>', '|'))
					return "Invalid character in UNC host name.";
				path = path[1 .. $];
			}
			if (path.length) path = path[1 .. $];
		}

		// stricter validation for the rest
		bool had_sep = false;
		foreach (i, char c; path) {
			if (c < 32 || c.among!('<', '>', '|', '?'))
				return "Invalid character in path.";
			if (isSeparator(c)) had_sep = true;
			else if (c == ':' && (had_sep || i+1 < path.length && !isSeparator(path[i+1])))
				return "Colon in path that is not part of a drive name.";

		}
		return null;
	}

	static string validateDecodedSegment(string segment)
	@nogc {
		auto pe = validatePath(segment);
		if (pe) return pe;
		foreach (char c; segment)
			if (isSeparator(c))
				return "Path segment contains separator character.";
		return null;
	}

	unittest {
		assert(validatePath("c:\\foo") is null);
		assert(validatePath("\\\\?\\c:\\foo") is null);
		assert(validatePath("//?\\c:\\foo") !is null);
		assert(validatePath("-foo/bar\\*\\baz") is null);
		assert(validatePath("foo\0bar") !is null);
		assert(validatePath("foo\tbar") !is null);
		assert(validatePath("\\c:\\foo") !is null);
		assert(validatePath("c:d\\foo") !is null);
		assert(validatePath("foo\\b:ar") !is null);
		assert(validatePath("foo\\bar:\\baz") !is null);
	}

	static string encodeSegment(string segment)
	{
		assert(segment.length == 0 || segment[$-1] != '/');
		return segment;
	}
}


/** Implements Unix/Linux path semantics.

	See_also: `WindowsPath`
*/
struct PosixPathFormat {
	static void toString(I, O)(I segments, O dst)
	{
		char lastsep = '\0';
		bool first = true;
		foreach (s; segments) {
			if (!first || lastsep) dst.put('/');
			else first = false;
			dst.put(s.name);
			lastsep = s.separator;
		}
		if (lastsep) dst.put('/');
	}

	unittest {
		import std.array : appender;
		struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }}
		string str(Segment[] segs...) { auto ret = appender!string; toString(segs, ret); return ret.data; }

		assert(str() == "");
		assert(str(Segment("",'/')) == "/");
		assert(str(Segment("foo",'/'), Segment("bar",'/')) == "foo/bar/");
		assert(str(Segment("",'/'), Segment("foo",'\0')) == "/foo");
		assert(str(Segment("",'\\'), Segment("foo",'\\')) == "/foo/");
		assert(str(Segment("f oo")) == "f oo");
		assert(str(Segment("foo"), Segment("bar")) == "foo/bar");
	}

@safe nothrow pure:
	enum defaultSeparator = '/';

	static bool isSeparator(dchar ch)
	@nogc {
		return ch == '/';
	}

	static string getAbsolutePrefix(string path)
	@nogc {
		if (path.length > 0 && path[0] == '/')
			return path[0 .. 1];
		return null;
	}

	unittest {
		assert(getAbsolutePrefix("/") == "/");
		assert(getAbsolutePrefix("/test") == "/");
		assert(getAbsolutePrefix("/test/") == "/");
		assert(getAbsolutePrefix("test/") == "");
		assert(getAbsolutePrefix("") == "");
		assert(getAbsolutePrefix("./") == "");
	}

	static string getFrontNode(string path)
	@nogc {
		import std.string : indexOf;
		auto idx = path.indexOf('/');
		return idx < 0 ? path : path[0 .. idx+1];
	}

	unittest {
		assert(getFrontNode("") == "");
		assert(getFrontNode("/bar") == "/");
		assert(getFrontNode("foo/bar") == "foo/");
		assert(getFrontNode("foo/") == "foo/");
		assert(getFrontNode("foo") == "foo");
	}

	static string getBackNode(string path)
	@nogc {
		if (!path.length) return path;
		foreach_reverse (i; 0 .. path.length-1)
			if (path[i] == '/')
				return path[i+1 .. $];
		return path;
	}

	unittest {
		assert(getBackNode("") == "");
		assert(getBackNode("/bar") == "bar");
		assert(getBackNode("foo/bar") == "bar");
		assert(getBackNode("foo/") == "foo/");
		assert(getBackNode("foo") == "foo");
	}

	static string validatePath(string path)
	@nogc {
		foreach (char c; path)
			if (c == '\0')
				return "Invalid NUL character in file name";
		return null;
	}

	static string validateDecodedSegment(string segment)
	@nogc {
		auto pe = validatePath(segment);
		if (pe) return pe;
		foreach (char c; segment)
			if (isSeparator(c))
				return "Path segment contains separator character.";
		return null;
	}

	unittest {
		assert(validatePath("-foo/bar*/baz?") is null);
		assert(validatePath("foo\0bar") !is null);
	}

	deprecated("Use decodeSingleSegment instead.")
	static auto decodeSegment(S)(string segment)
	{
		assert(segment.length > 0, "Path segment string must not be empty.");
		import std.range : only;
		if (!segment.length) return only(S.fromTrustedString(null, '/'));
		if (segment[$-1] == '/')
			return only(S.fromTrustedString(segment[0 .. $-1], '/'));
		return only(S.fromTrustedString(segment));
	}

	deprecated unittest {
		struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }}
		assert(decodeSegment!Segment("foo").equal([Segment("foo")]));
		assert(decodeSegment!Segment("foo/").equal([Segment("foo", '/')]));
		assert(decodeSegment!Segment("fo%20o\\").equal([Segment("fo%20o\\")]));
	}

	static string decodeSingleSegment(string segment)
	@nogc {
		assert(segment.length == 0 || segment[$-1] != '/');
		return segment;
	}

	unittest {
		struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }}
		assert(decodeSingleSegment("foo") == "foo");
		assert(decodeSingleSegment("fo%20o\\") == "fo%20o\\");
	}

	static string encodeSegment(string segment)
	{
		assert(segment.length == 0 || segment[$-1] != '/');
		return segment;
	}
}


/** Implements URI/Internet path semantics.

	See_also: `WindowsPath`
*/
struct InetPathFormat {
	static void toString(I, O)(I segments, O dst)
	{
		char lastsep = '\0';
		bool first = true;
		foreach (e; segments) {
			if (!first || lastsep) dst.put('/');
			else first = false;
			static if (is(typeof(e.encodedName)))
				dst.put(e.encodedName);
			else encodeSegment(dst, e.name);
			lastsep = e.separator;
		}
		if (lastsep) dst.put('/');
	}

	unittest {
		import std.array : appender;
		struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }}
		string str(Segment[] segs...) { auto ret = appender!string; toString(segs, ret); return ret.data; }
		assert(str() == "");
		assert(str(Segment("",'/')) == "/");
		assert(str(Segment("foo",'/'), Segment("bar",'/')) == "foo/bar/");
		assert(str(Segment("",'/'), Segment("foo",'\0')) == "/foo");
		assert(str(Segment("",'\\'), Segment("foo",'\\')) == "/foo/");
		assert(str(Segment("f oo")) == "f%20oo");
		assert(str(Segment("foo"), Segment("bar")) == "foo/bar");
	}

@safe pure nothrow:
	enum defaultSeparator = '/';

	static bool isSeparator(dchar ch)
	@nogc {
		return ch == '/';
	}

	static string getAbsolutePrefix(string path)
	@nogc {
		if (path.length > 0 && path[0] == '/')
			return path[0 .. 1];
		return null;
	}

	unittest {
		assert(getAbsolutePrefix("/") == "/");
		assert(getAbsolutePrefix("/test") == "/");
		assert(getAbsolutePrefix("/test/") == "/");
		assert(getAbsolutePrefix("test/") == "");
		assert(getAbsolutePrefix("") == "");
		assert(getAbsolutePrefix("./") == "");
	}

	static string getFrontNode(string path)
	@nogc {
		import std.string : indexOf;
		auto idx = path.indexOf('/');
		return idx < 0 ? path : path[0 .. idx+1];
	}

	unittest {
		assert(getFrontNode("") == "");
		assert(getFrontNode("/bar") == "/");
		assert(getFrontNode("foo/bar") == "foo/");
		assert(getFrontNode("foo/") == "foo/");
		assert(getFrontNode("foo") == "foo");
	}

	static string getBackNode(string path)
	@nogc {
		import std.string : lastIndexOf;

		if (!path.length) return path;
		ptrdiff_t idx;
		try idx = path[0 .. $-1].lastIndexOf('/');
		catch (Exception e) assert(false, e.msg);
		if (idx >= 0) return path[idx+1 .. $];
		return path;
	}

	unittest {
		assert(getBackNode("") == "");
		assert(getBackNode("/bar") == "bar");
		assert(getBackNode("foo/bar") == "bar");
		assert(getBackNode("foo/") == "foo/");
		assert(getBackNode("foo") == "foo");
	}

	static string validatePath(string path)
	@nogc {
		for (size_t i = 0; i < path.length; i++) {
			if (isAsciiAlphaNum(path[i]))
				continue;

			switch (path[i]) {
				default:
					return "Invalid character in internet path.";
				// unreserved
				case '-', '.', '_', '~':
				// subdelims
				case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=':
            	// additional delims
            	case ':', '@':
            	// segment delimiter
            	case '/':
            		break;
            	case '%': // pct encoding
            		if (path.length < i+3)
            			return "Unterminated percent encoding sequence in internet path.";
            		foreach (j; 0 .. 2) {
            			switch (path[++i]) {
            				default: return "Invalid percent encoding sequence in internet path.";
            				case '0': .. case '9':
            				case 'a': .. case 'f':
            				case 'A': .. case 'F':
            					break;
            			}
            		}
            		break;
			}
		}
		return null;
	}

	static string validateDecodedSegment(string seg)
	@nogc {
		return null;
	}

	unittest {
		assert(validatePath("") is null);
		assert(validatePath("/") is null);
		assert(validatePath("/test") is null);
		assert(validatePath("test") is null);
		assert(validatePath("/C:/test") is null);
		assert(validatePath("/test%ab") is null);
		assert(validatePath("/test%ag") !is null);
		assert(validatePath("/test%a") !is null);
		assert(validatePath("/test%") !is null);
		assert(validatePath("/test§") !is null);
		assert(validatePath("föö") !is null);
	}

	deprecated("Use decodeSingleSegment instead.")
	static auto decodeSegment(S)(string segment)
	{
		import std.algorithm.searching : any;
		import std.array : array;
		import std.exception : assumeUnique;
		import std.range : only;
		import std.utf : byCodeUnit;

		if (!segment.length) return only(S.fromTrustedString(null));
		char sep = '\0';
		if (segment[$-1] == '/') {
			sep = '/';
			segment = segment[0 .. $-1];
		}

		if (!segment.byCodeUnit.any!(c => c == '%'))
			return only(S(segment, sep));
		string n = decodeSingleSegment(segment).array;
		return only(S(n, sep));
	}

	deprecated unittest {
		struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }}
		assert(decodeSegment!Segment("foo").equal([Segment("foo")]));
		assert(decodeSegment!Segment("foo/").equal([Segment("foo", '/')]));
		assert(decodeSegment!Segment("fo%20o\\").equal([Segment("fo o\\")]));
		assert(decodeSegment!Segment("foo%20").equal([Segment("foo ")]));
	}

	static auto decodeSingleSegment(string segment)
	@nogc {
		import std.string : indexOf;

		static int hexDigit(char ch) @safe nothrow @nogc {
			assert(ch >= '0' && ch <= '9' || ch >= 'A' && ch <= 'F' || ch >= 'a' && ch <= 'f');
			if (ch >= '0' && ch <= '9') return ch - '0';
			else if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
			else return ch - 'A' + 10;
		}

		static struct R {
			@safe pure nothrow @nogc:

			private {
				string m_str;
				size_t m_index;
			}

			this(string s)
			{
				m_str = s;
			}

			@property bool empty() const { return m_index >= m_str.length; }

			@property R save() const { return this; }

			@property char front()
			const {
				auto ch = m_str[m_index];
				if (ch != '%') return ch;

				auto a = m_str[m_index+1];
				auto b = m_str[m_index+2];
				return cast(char)(16 * hexDigit(a) + hexDigit(b));
			}

			@property void popFront()
			{
				assert(!empty);
				if (m_str[m_index] == '%') m_index += 3;
				else m_index++;
			}
		}

		return R(segment);
	}

	unittest {
		scope (failure) assert(false);

		assert(decodeSingleSegment("foo").equal("foo"));
		assert(decodeSingleSegment("fo%20o\\").equal("fo o\\"));
		assert(decodeSingleSegment("foo%20").equal("foo "));
	}


	static string encodeSegment(string segment)
	{
		import std.array : appender;

		foreach (i, char c; segment) {
			if (isAsciiAlphaNum(c)) continue;
			switch (c) {
				default:
					auto ret = appender!string;
					ret.put(segment[0 .. i]);
					encodeSegment(ret, segment[i .. $]);
					return ret.data;
				case '-', '.', '_', '~':
				case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=':
        		case ':', '@':
					break;
			}
		}

		return segment;
	}

	unittest {
		assert(encodeSegment("foo") == "foo");
		assert(encodeSegment("foo bar") == "foo%20bar");
	}

	static void encodeSegment(R)(ref R dst, string segment)
	{
		static immutable char[16] digit = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'];

		foreach (char c; segment) {
			switch (c) {
				default:
					dst.put('%');
					dst.put(digit[uint(c) / 16]);
					dst.put(digit[uint(c) % 16]);
					break;
				case 'a': .. case 'z':
				case 'A': .. case 'Z':
				case '0': .. case '9':
				case '-', '.', '_', '~':
				case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=':
        		case ':', '@':
					dst.put(c);
					break;
			}
		}
	}
}

private auto extension(R)(R filename)
	if (isForwardRange!R && isSomeChar!(ElementType!R))
{
	if (filename.empty) return filename;

	static if (isArray!R) { // avoid auto decoding
		filename = filename[1 .. $]; // ignore leading dot

		R candidate;
		while (filename.length) {
			if (filename[0] == '.')
				candidate = filename;
			filename = filename[1 .. $];
		}
		return candidate;
	} else {
		filename.popFront(); // ignore leading dot

		R candidate;
		while (!filename.empty) {
			if (filename.front == '.')
				candidate = filename.save;
			filename.popFront();
		}
		return candidate;
	}
}

@safe nothrow unittest {
	assert(extension("foo") == "");
	assert(extension("foo.txt") == ".txt");
	assert(extension(".foo") == "");
	assert(extension(".foo.txt") == ".txt");
	assert(extension("foo.bar.txt") == ".txt");
}

unittest {
	assert(extension(InetPath("foo").head2.name).equal(""));
	assert(extension(InetPath("foo.txt").head2.name).equal(".txt"));
	assert(extension(InetPath(".foo").head2.name).equal(""));
	assert(extension(InetPath(".foo.txt").head2.name).equal(".txt"));
	assert(extension(InetPath("foo.bar.txt").head2.name).equal(".txt"));
}


private auto stripExtension(R)(R filename)
	if (isForwardRange!R && isSomeChar!(ElementType!R))
{
	static if (isArray!R) { // make sure to return a slice
		if (!filename.length) return filename;
		R r = filename;
		r = r[1 .. $]; // ignore leading dot
		size_t cnt = 0, rcnt = r.length;
		while (r.length) {
			if (r[0] == '.')
				rcnt = cnt;
			cnt++;
			r = r[1 .. $];
		}
		return filename[0 .. rcnt + 1];
	} else {
		if (filename.empty) return filename.takeExactly(0);
		R r = filename.save;
		size_t cnt = 0, rcnt = size_t.max;
		r.popFront(); // ignore leading dot
		while (!r.empty) {
			if (r.front == '.')
				rcnt = cnt;
			cnt++;
			r.popFront();
		}
		if (rcnt == size_t.max) return filename.takeExactly(cnt + 1);
		return filename.takeExactly(rcnt + 1);
	}
}

@safe nothrow unittest {
	assert(stripExtension("foo") == "foo");
	assert(stripExtension("foo.txt") == "foo");
	assert(stripExtension(".foo") == ".foo");
	assert(stripExtension(".foo.txt") == ".foo");
	assert(stripExtension("foo.bar.txt") == "foo.bar");
}

unittest { // test range based path
	import std.utf : byWchar;

	assert(stripExtension("foo".byWchar).equal("foo"));
	assert(stripExtension("foo.txt".byWchar).equal("foo"));
	assert(stripExtension(".foo".byWchar).equal(".foo"));
	assert(stripExtension(".foo.txt".byWchar).equal(".foo"));
	assert(stripExtension("foo.bar.txt".byWchar).equal("foo.bar"));

	assert(stripExtension(InetPath("foo").head2.name).equal("foo"));
	assert(stripExtension(InetPath("foo.txt").head2.name).equal("foo"));
	assert(stripExtension(InetPath(".foo").head2.name).equal(".foo"));
	assert(stripExtension(InetPath(".foo.txt").head2.name).equal(".foo"));
	assert(stripExtension(InetPath("foo.bar.txt").head2.name).equal("foo.bar"));
}

private static bool isAsciiAlphaNum(char ch)
@safe nothrow pure @nogc {
	return (uint(ch) & 0xDF) - 0x41 < 26 || uint(ch) - '0' <= 9;
}

unittest {
	assert(!isAsciiAlphaNum('@'));
	assert(isAsciiAlphaNum('A'));
	assert(isAsciiAlphaNum('Z'));
	assert(!isAsciiAlphaNum('['));
	assert(!isAsciiAlphaNum('`'));
	assert(isAsciiAlphaNum('a'));
	assert(isAsciiAlphaNum('z'));
	assert(!isAsciiAlphaNum('{'));
	assert(!isAsciiAlphaNum('/'));
	assert(isAsciiAlphaNum('0'));
	assert(isAsciiAlphaNum('9'));
	assert(!isAsciiAlphaNum(':'));
}

unittest { // regression tests
	assert(NativePath("").bySegment.empty);
	assert(NativePath("").bySegment2.empty);
}