// IE GM SAS Ripper
// Davy Pizdunov 2010 (L)

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <map>
#include <set>
#include <vector>
#include <cctype>
#include <algorithm>

using std::string;
using std::cout;

namespace gl
{
	string int2str(int x, int width=0, char pad='0');
	string tos(int x);
	int sto(const string &s);
	void replaceAll(string &s, const string &r, const string &to);
	void eatEndl(string &s);
	string getline(std::istream&);
	void str2file(const std::string &filename, const std::string &s);
	std::string file2str(const std::string &filename);
	bool isfile(const string &f);
	string toLower(string s);
	string toUpper(string s);

	void addForwardSlash(string &s);

}// gl


namespace dir{

	typedef std::map<string, std::pair<unsigned long, long> > msul;
	// returns name, time, size( -1L for a subdirectory )
	msul readdir();

	bool setd(string s);
	string getd();
	bool make(string);
	bool remove(string);
	bool rename(string old, string n);
	bool matchExt(const string& s, const string& ext);

	inline bool isFolder(const string &dir)
	{
		string cwd =getd();
		if( !setd(dir) ) return false;
		setd(cwd);
		return true;
	}


	class in{
		string cwd;
	public:
		in(string s)
		{ 
			cwd=getd(); 
			if( !setd(s) ) 
			{
				throw string("dir::in: cannot get into [")+s+"]"; 
			}
		}

		~in(){ setd(cwd); }
	};

} //dir





// Classes


struct Tile
{
	string apath, rpath, name, ext;
	string lyr;
	int x,y,z;

	Tile(string ap, string rp, string nm, bool my);

	bool operator<(const Tile& t) const;
};

class Cache
{
	string mCurrentDir;
	string mCurrentPath;

	std::set<Tile> mTiles;

public:
	Cache(string path);

	int size() const { return mTiles.size(); }
	void add(Tile t){ mTiles.insert(t); }

	const std::set<Tile> & getTiles() const { return mTiles; }
};

class Ie
{
	string mDir;
	string mPath;
	string mGmPath;
	string mSasPath;

	std::set<Tile> mTiles;

public:
	Ie(string path, string gmpath, string spath);
	void skip(const Cache &c);
	void save(Cache &c);

	string aPath() const { return mPath; }
	int size() const { return mTiles.size(); }
	void add(Tile t){ mTiles.insert(t); }
};

struct DirVisitor
{
	string rpath;
	virtual void file(string name, string rpath) = 0;
	void go();
};


struct CacheVisitor: DirVisitor
{
	Cache * pc;
	CacheVisitor(Cache *p, string rp): pc(p) { rpath=rp; }
	void file(string name, string rpath);
};

struct IeVisitor: DirVisitor
{
	Ie * pi;
	IeVisitor(Ie *p, string rp): pi(p) { rpath=rp; }
	void file(string name, string rpath);
};

void CacheVisitor::file(string name, string rpath)
{
	Tile t("",rpath,name,true);
	if( t.lyr=="" ) return;
	pc->add(t);
	if( !(pc->size()%100) ) cout<<pc->size()<<'\r';
}

void IeVisitor::file(string name, string rpath)
{
	Tile t(pi->aPath(),rpath,name,false);
	if( t.lyr=="" ) return;
	pi->add(t);
	if( !(pi->size()%100) ) cout<<pi->size()<<'\r';
}






string getIePath();

int main(int ac, const char *av[])
	try{

		string iepath = getIePath();

		int n = 1;
		int tm = 300;

		if( ac>= 2 ) n = atoi(av[1]);
		if( ac>2 ) tm = atoi(av[2]);

		while(1)
		{

			cout<<"Scanning data\n"<<std::flush;
			Cache c("gm");
			cout<<c.size()<<"\n";

			cout<<"Scanning cache\n"<<std::flush;
			Ie ie(iepath,"gm/iegmrip","cache");
			cout<<ie.size()<<"\n";

			cout<<"Copying "<<std::flush;

			ie.skip(c);

			cout<<ie.size()<<"\n";

			ie.save(c);

			cout<<"done\n";

			if( !--n ) break;

			for( int i=0; i<100; i++ )
			{
				_sleep(tm);
				cout<<i<<'\r';
			}
		}

}
catch(string s)
{
	cout<<"Error: "<<s<<'\n';
}


string getIePath()
{
	std::ifstream in("iegmrip.in");
	if( !in )
	{
		const char * drv = getenv("HOMEDRIVE");
		const char * path = getenv("HOMEPATH");
		string r = string()+drv+path+"\\Local Settings\\Temporary Internet Files\\";
		std::cout<<"iegmrip.in not found, using default directory:\n"<<r<<'\n';
		return r;
	}

	string r = gl::getline(in).substr(2);
	std::cout<<"Using IE directory: "<<r<<'\n';
	return r;
}

void gl::eatEndl(string &s)
{
	while( s.size() && (s[s.size()-1]=='\r' || s[s.size()-1]=='\n') ) 
		s.erase(s.size()-1,1);
}

string gl::getline(std::istream& is)
{
	string r;
	std::getline(is,r);
	eatEndl(r);
	return r;
}

namespace to{
	inline char tolower(char x){ return std::tolower(x); }
	inline char toupper(char x){ return std::toupper(x); }
}

string gl::toLower(string s)
{
	// explicit cast needed to resolve ambiguity
	std::transform(s.begin(), s.end(), s.begin(), to::tolower);
	return s;
}

string gl::toUpper(string s)
{
	// explicit cast needed to resolve ambiguity
	std::transform(s.begin(), s.end(), s.begin(), to::toupper);
	return s;
}

void gl::replaceAll(string &s, const string &r, const string &to)
{
	while(1)
	{
		string::size_type i = s.find(r);
		if( i==string::npos ) return;
		s.replace(i,r.size(),to);
	}
}


void gl::addForwardSlash(string& s)
{
	if( s.size() && s[ s.size()-1 ] != '/' ) s+='/';
}


bool Tile::operator<(const Tile& t) const
{
	if( lyr < t.lyr ) return false;
	if( lyr > t.lyr ) return true;

	if( z < t.z ) return false;
	if( z > t.z ) return true;

	if( x < t.x ) return false;
	if( x > t.x ) return true;

	return y<t.y;

}

bool parseMyName(string nm, string &lyr, int &x, int &y, int &z)
{
	gl::replaceAll(nm,"."," ");
	gl::replaceAll(nm,"_"," ");

	std::istringstream is(nm);

	x=y=z=-1;
	is>>lyr>>z>>x>>y;

	if( z>=0 )
	{
		//cout<<" $("<<lyr<<' '<<z<<' '<<x<<' '<<y<<") ";
		return true;
	}

	return false;
}

int getValue(const string &s, const string &k)
{
	string::size_type ix = s.find(k+"=");
	string::size_type ixe = s.find("&",ix);

	if( ixe==string::npos )
		throw "cannot find 'x='";

	ix+=2;

	string sx = s.substr(ix,ixe-ix);

	return gl::sto(sx);
}

int gl::sto(const string &s)
{
	int x;
	std::istringstream is(s);
	is>>x;
	return x;
}


bool parseUrlName(string nm, string &lyr, int &x, int &y, int &z)
{
	int itype = 0;

	if( dir::matchExt(nm,"jpg") ) itype = 1;
	if( dir::matchExt(nm,"png") ) itype = 2;

	if( !itype ) return false;

	if( nm.find("&x=") == string::npos ) return false;
	if( nm.find("&y=") == string::npos ) return false;
	if( nm.find("&z=") == string::npos ) return false;
	if( nm.find("&s=") == string::npos ) return false;

	if( itype == 2 )
	{
		if( nm.find("lyrs=m@") != string::npos )
		{
			itype = 3;
			lyr = "map";
		}
		else if( nm.find("lyrs=h@") != string::npos )
			lyr = "lyr";
		else
			return false;
	}
	else lyr = "sat";

	x = getValue(nm,"x");
	y = getValue(nm,"y");
	z = getValue(nm,"z");

	//cout<<" $("<<lyr<<' '<<z<<' '<<x<<' '<<y<<") ";
	return true;
}

Tile::Tile(string ap, string rp, string nm, bool my)
	: apath(ap), rpath(rp), name(nm)
{
	if( dir::matchExt(nm,"jpg") ) ext = ".jpg";
	if( dir::matchExt(nm,"png") ) ext = ".png";

	if( my )
	{
		if( parseMyName(nm,lyr,x,y,z) ) return;
	}
	else
	{
		if( parseUrlName(nm,lyr,x,y,z) ) return;
	}

	lyr = "";
	z=-1;
}

void DirVisitor::go()
{
	dir::msul e = dir::readdir();

	for( dir::msul::iterator i=e.begin(); i!=e.end(); ++i )
	{
		if( i->second.second == -1L )
		{
			string rp = rpath;
			rpath += i->first+"/";
			dir::in ind(i->first);
			go();
			rpath = rp;
		}
		else
			file( i->first, rpath );
	}
}

Cache::Cache(string p)
{
	mCurrentDir = dir::getd();
	mCurrentPath = mCurrentDir;
	gl::replaceAll(mCurrentPath,"\\","/");
	gl::addForwardSlash(mCurrentPath);

	dir::make(p);
	string pr = p+"/iegmrip";
	dir::make(pr);

	CacheVisitor cv(this,p);

	dir::in ind(p);

	cv.go();
}

Ie::Ie(string p, string gmp, string sas)
{
	mDir = p;
	mPath = mDir;
	mGmPath = gmp;
	mSasPath = sas;

	dir::make(sas);

	gl::replaceAll(mPath,"\\","/");
	gl::addForwardSlash(mPath);

	IeVisitor iv(this,"");

	dir::in ind(mDir);

	iv.go();
}

void Ie::skip(const Cache &c)
{
	const std::set<Tile> & ct = c.getTiles();

	for( std::set<Tile>::const_iterator i=ct.begin(); i!=ct.end(); ++i )
	{
		std::set<Tile>::iterator j = mTiles.find(*i);
		if( j != mTiles.end() )
		{
			mTiles.erase(j);
		}
	}
}

void Ie::save(Cache &c)
{
	for( std::set<Tile>::const_iterator i=mTiles.begin(); i!=mTiles.end(); ++i )
	{

		Tile t = *i;
		// load
		string file;
		{
			dir::in ind(mDir);
			string file2read(t.rpath+t.name);
			file = gl::file2str(file2read);
		}

		{
			dir::in ind(mGmPath);
			string f2s;

			{
				string xc = gl::int2str(t.x,7);
				string yc = gl::int2str(t.y,7);
				string zc = gl::int2str(t.z,2);

				string name = t.lyr+'_'+zc+'_'+xc+'_'+yc+t.ext;

				dir::make(zc);
				dir::make(zc+'/'+t.lyr);
				dir::make(zc+'/'+t.lyr+'/'+xc);

				f2s = zc+'/'+t.lyr+'/'+xc+'/'+name;
			}

			gl::str2file( f2s, file );
		}

		{
			dir::in ind(mSasPath);
			string f2s;

			{
				string xc = gl::int2str(t.x);
				string yc = gl::int2str(t.y);
				string xd = gl::int2str(t.x/1024);
				string yd = gl::int2str(t.y/1024);
				string zc = gl::int2str(t.z+1);
				string slr;
				if( t.lyr=="sat" ) slr="SAT";
				if( t.lyr=="map" ) slr="MAP";
				if( t.lyr=="lyr" ) slr="BOTH";

				string name = 'y'+yc+t.ext;

				dir::make(slr);
				dir::make(slr+"/z"+zc);
				dir::make(slr+"/z"+zc+'/'+xd);
				dir::make(slr+"/z"+zc+'/'+xd+"/x"+xc);
				dir::make(slr+"/z"+zc+'/'+xd+"/x"+xc+'/'+yd);

				f2s = slr+"/z"+zc+'/'+xd+"/x"+xc+'/'+yd+'/'+name;
			}

			gl::str2file( f2s, file );
		}

		{
			static int si=0;
			if( !(++si%10) ) cout<<si<<"\r"<<std::flush;
		}
	}
	cout<<"            \r";
}

bool gl::isfile(const string &f)
{
	std::ifstream in(f.c_str());
	bool r = in.is_open();

	return r;
}

string gl::file2str(const string &filename)
{
	std::ifstream in(filename.c_str(),std::ios::binary);
	string sin;
	while(1)
	{
		char a='\0';
		in.get(a);
		if( !in ) break;
		sin += a;
	}
	return sin;
}

void gl::str2file(const std::string &filename, const std::string &s)
{
	std::ofstream of(filename.c_str(),std::ios::binary);
	of<<s;
}

string gl::int2str(int x, int pr, char pad)
{
	const int BUF_SIZE = 100;
	char buf[BUF_SIZE]; 
	std::sprintf(buf,"%d",x);
	if( !pr ) return buf;

	string s = buf;
	while( s.size() < static_cast<unsigned>(pr) )
	{
		if( s.size() && s[0]=='-' )
		{
			s[0] = pad;
			s = '-' + s;
		}
		else
			s = pad+s;
	}
	return s;
}


// Windows specifics


#include <direct.h>
#include <io.h>

dir::msul dir::readdir()
{

	std::map<string,std::pair<unsigned long, long> > r;
	_finddata_t f;
	long handle;

	if ( (handle = _findfirst("*",&f) ) != -1L )

		do {
			// f.name f.size, (f.attrib & _A_SUBDIR) 

			std::pair<unsigned long, long> atr;

			atr.first = f.time_write;

			if( !(f.attrib & _A_SUBDIR)  )
				atr.second =  f.size;
			else
				atr.second =  -1L;

			string name(f.name);

			if( name != "." && name != ".." ) 
				r[name] = atr;

		}while( _findnext(handle,&f) != -1 );

	_findclose(handle);

	return r;
}


bool dir::setd(string s){ return !_chdir(s.c_str()); }

string dir::getd(){ 
	int size = 100;
	char * p = new char[size];
	char * r = _getcwd(p,size);
	while( !r ){
		delete[] p;
		if( size > 1000000L ) return "";
		size*=2;
		p = new char[size];
		r = _getcwd(p,size);
	}

	string rr(r);
	delete[] p;
	return rr;

}

bool dir::make(string s){ return !_mkdir(s.c_str()); }

bool dir::remove(string s){	return !_rmdir(s.c_str()); }

bool dir::rename(string old, string n)
{
	//if( MoveFileEx(old.c_str(), n.c_str(), MOVEFILE_REPLACE_EXISTING )!=0 )
	if( ::rename(old.c_str(), n.c_str()) == 0 )
		return true;
	else
		return false;
}

bool dir::matchExt(const string& s, const string& e)
{
	string::size_type i = s.rfind(".");
	if( i==string::npos ) return false;
	string r = s.substr(i+1);
	return gl::toLower(r)==gl::toLower(e);
}