//author: bobef
//license: use without restrictions at your own risk

import std.stdio;
import std.string;
import std.path;
import std.file;

version=t_Windows;

version(t_Windows) static const char[1] std_path_sep="\\";
version(t_Linux) static const char[1] std_path_sep="/";

char[] fixPath(char[] s)
{
	version(t_Windows){return replace(s,"/","\\");}
	version(t_Linux){return replace(s,"\\","/");}
}

char[] getFullPath(char[] path)
{
	if(!path.length) return null;
	path=fixPath(path);
	version(Linux) path=expandTilde(path);

	version(Windows) if(getDrive(path).length) return _cleanPath(path,0);
	if(path[0]==std_path_sep[0])
	{
		version(Windows) return cleanPath(getDrive(getcwd())~path);
		version(Linux) return cleanPath(path);
	}
	else return cleanPath(getcwd()~std_path_sep~path);
}

int getRelativePath(char[] basepath,char[] destpath,out char[] ret)
{
	basepath=fixPath(basepath);
	destpath=fixPath(destpath);
	if(!destpath.length) return 0;
	if(!basepath.length) {ret=destpath;return 1;}
	if(basepath[basepath.length-1]==std_path_sep[0]) basepath.length=basepath.length-1;
	if(destpath[destpath.length-1]==std_path_sep[0]) destpath.length=destpath.length-1;
	version(Windows)
	{
		char[] drv1=_getDrive(basepath,0);
		char[] drv2=_getDrive(destpath,0);
		int s1=0,s2=0;
		if(drv1.length && drv2.length &&  drv1!=drv2) {ret=destpath;return 1;}
		else
		{
			if(drv1.length) s1=drv1.length+1;
			if(drv2.length) s2=drv2.length+1;
		}
		char[][] basedirs = s1<basepath.length?split(basepath[s1..basepath.length],std_path_sep):null;
		char[][] destdirs = s2<destpath.length?split(destpath[s2..destpath.length],std_path_sep):null;
	}
	version(Linux)
	{
		char[][] basedirs = split(basepath,std_path_sep);
		char[][] destdirs = split(destpath,std_path_sep);
	}

	int maxCompare=basedirs.length>=destdirs.length?destdirs.length:basedirs.length;
	int lastCommonDir=-1;
	for (int i=0; i<maxCompare; i++)
	{
		if (basedirs[i] != destdirs[i]) break;
		lastCommonDir=i;
	} 

	int l1=lastCommonDir+1;
	int end=basedirs.length-(l1);
	int end2=end-1;
	for (uint i=0;i<end; i++) ret ~= ".."~(i<end2?std_path_sep:"");
	if(destdirs.length>l1)
	{
		destdirs=destdirs[l1..destdirs.length].dup; //do we need dup?
		if(end>0) ret~=std.path.sep;
	}
	else destdirs=null;
	if(destdirs.length) ret ~= _cleanPath(std.string.join(destdirs,std_path_sep),0);
	return 1;
}

char[] getDrive(char[] path)
{
	version(t_Linux) return null;
	version(t_Windows) return _getDrive(path,1);
}

private char[] _getDrive(char[] path,int fix)
{
	version(Linux) return null;
	version(Windows)
	{
		if(path.length<2) return null;
		if(fix) path=fixPath(path);
	
		if(path[0..2]=="\\\\")
		{
			int r=find(path[2..path.length],std_path_sep);
			if(r>0) return path[0..r+2];
			else return path;
		}
		else
		{
			int r=find(path,':');
			if(r>0) return path[0..r+1];
			else return null;
		}
	}
}

char[] cleanPath(char[] path){return _cleanPath(path,1);}

private char[] _cleanPath(char[] path,int fix)
{
	if(fix) path=fixPath(path);
	char[][] as=split(path,std_path_sep);
	int[] i;
	version(Windows) int mindir=_getDrive(path,0).length?1:0;
	if(as.length)
	{
		for(int c=0;c<as.length;c++)
		{
			if(as[c]==".") continue;
			else if(as[c]=="..")
			{
				version(Windows) if(i.length>mindir)
				if(i.length) i.length=i.length-1;
				else {if(as[c].length || (!as[c].length && !c)) i~=c;} //do not skip initial slash
			}
			else {if(as[c].length || (!as[c].length && !c)) i~=c;} //do not skip initial slash
		}
		char[] ret;
		version(Linux) ret=std_path_sep;
		int end=i.length-1;
		for(int c=0;c<i.length;c++) ret~=as[i[c]]~(c<end?std_path_sep:"");
		return ret;
	}
	else
	{
		version(Windows) return path;
		version(Linux) return std_path_sep~path;
	}
}

void main()
{
	version(t_Windows)
	{
		writefln("\ngetRelativePath tests\n");

		char[] ret;
		getRelativePath("c:\\elephant\\cat\\dog","d:\\mickey\\mouse",ret);writefln(ret); //different drives test
		getRelativePath("c:\\elephant\\cat\\dog","c:/elephant",ret);writefln(ret); //mixed slashes
		getRelativePath("\\\\elephant\\cat\\dog","\\\\elephant\\cat",ret);writefln(ret); //network
		getRelativePath("\\\\elephant\\cat\\dog","\\\\cat\\dog",ret);writefln(ret);
		getRelativePath("c:\\elephant\\cat\\dog","c:\\cat\\dog",ret);writefln(ret);
		getRelativePath("c:\\elephant\\cat\\dog","c:\\elephant\\cat\\mouse\\..\\bird",ret);writefln(ret);
		getRelativePath("c:\\cat","c:\\cat\\dog.d",ret);writefln(ret);
		//more?

		writefln("\ncleanPath tests\n");

		writefln(cleanPath("c:\\rabbit\\..\\bird"));
		writefln(cleanPath(".\\rabbit\\..\\bird"));
		writefln(cleanPath("rabbit\\..\\.\\bird"));
		writefln(cleanPath("\\rabbit\\"));
		writefln(cleanPath(".\\rabbit\\\\asd"));
		//more?

		writefln("\ngetFullPath tests\n");

		writefln(getFullPath("c:\\rabbit/..\\bird"));
		writefln(getFullPath("c:\\rabbit\\cat\\..\\bird"));
		writefln(getFullPath("\\rabbit\\..\\bird"));
		writefln(getFullPath("rabbit.d"));
		writefln(getFullPath("rabbit\\..\\.\\bird"));
		writefln(getFullPath(".\\rabbit\\..\\.\\bird\\..\\"));
		writefln(getFullPath("c:\\rabbit\\..\\..\\..\\bird")); // is this correct?
		//more?
	}
	version(t_Linux)
	{
		writefln("\ngetRelativePath tests\n");

		char[] ret;
		getRelativePath("\\elephant\\cat\\dog","\\mickey\\mouse",ret);writefln(ret); //different drives test
		getRelativePath("\\elephant\\cat\\dog","/elephant",ret);writefln(ret); //mixed slashes
		getRelativePath("\\elephant\\cat\\dog","\\cat\\dog",ret);writefln(ret);
		getRelativePath("\\elephant\\cat\\dog","\\elephant\\cat\\mouse\\..\\bird",ret);writefln(ret);
		//more?

		writefln("\ncleanPath tests\n");

		writefln(cleanPath("\\rabbit\\..\\bird"));
		writefln(cleanPath(".\\rabbit\\..\\bird"));
		writefln(cleanPath("rabbit\\..\\.\\bird"));
		writefln(cleanPath("\\rabbit\\"));
		writefln(cleanPath(".\\rabbit\\\\asd"));
		//more?

		writefln("\ngetFullPath tests\n");

		writefln(getFullPath("\\rabbit/..\\bird"));
		writefln(getFullPath("\\rabbit\\cat\\..\\bird"));
		writefln(getFullPath("\\rabbit\\..\\bird"));
		writefln(getFullPath("rabbit.d"));
		writefln(getFullPath("rabbit\\..\\.\\bird"));
		writefln(getFullPath(".\\rabbit\\..\\.\\bird\\..\\"));
		writefln(getFullPath("\\rabbit\\..\\..\\..\\bird")); // is this correct?
		//more?
	}
}