module fakerjsgenerator;

import std.array;
import std.stdio;
import std.process;
import std.format;
import std.conv : to;
import std.exception : enforce;
import std.file : dirEntries, SpanMode, isDir, readText, isFile, exists,
       mkdirRecurse;
import std.algorithm;
import std.string;
import std.regex;

import jssplitter;
import generator;
import iban;

enum outputDir = "../source/faked/";

void main() {
	cloneFaker();
	FakerData[] locales = scrapeFakers();
    mkdirRecurse(outputDir);

    auto list = [
        "af_ZA", "de", "en_CA", "en_US", /*"fa",*/ "ge", "ko", "nl", "pt_PT",
        "sv", "zh_CN", /*"ar",*/ "de_AT", "en_AU", "en_GB", "en_ZA", "fr", "id_ID",
        "lv", "nl_BE", "ro", "tr", "zh_TW", /*"az",*/ "de_CH", "en_au_ocker",
        "en_IE", "es", "fr_CA", "it", "nb_NO", "pl", "ru", "uk", "zu_ZA",
        /*"cz",*/ "el", "en_BORK", "en_IND", /*"es_MX",*/ "fr_CH", "ja", "nep",
        "pt_BR", /*"sk",*/ "vi"

    ];

    auto en = locales.find!(a => a.locale == "en").front;
    string[] methods = buildFile("en", en, []);
    methods ~= ["addressLatitude", "addressLongitude", "fianceAccount",
        "fianceRoutingNumber", "financeMask", "financeBitcoinAddress",
        "phoneNumber", "commerceProductName", "companyCatchPhrase",
        "companyBs", "internetUserName", "internetProtocol",
        "internetDomainWord", "internetDomainName", "internetUrl",
        "internetIPv4", "internetIPv6", "internetColor", "internetPassword",
        "vehicle", "vehicleVin", "helperAlpha", "helperAlphaNum",
        "helperHexaDecimal",
    ];
    methods = methods.sort.uniq.array;

    writefln("%(%s\n%)", methods);
    foreach(ll; list) {
        writeln(ll);
	    auto f = locales.find!(a => a.locale == ll);
        assert(!f.empty, ll);
        buildFile(ll, f.front, methods);
    }

    buildInstantionTest(list ~ "en", methods);

    writePackageFile(list);
}

void writePackageFile(string[] list) {
    auto f = File(outputDir ~ "package.d", "w");
    auto ltw = f.lockingTextWriter();

    formattedWrite(ltw, "// generated by fakerjsgenerator\n");
    formattedWrite(ltw, "module faked;\n\n");
    formattedWrite(ltw, "///\npublic import faked.base;\n\n");
    foreach(l; list) {
        formattedWrite(ltw, "///\npublic import faked.faker_%s;\n\n", toLower(l));
    }
}

void buildInstantionTest(string[] list, string[] methods) {
    auto f = File(outputDir ~ "test.d", "w");
    auto ltw = f.lockingTextWriter();
    formattedWrite(ltw, "// generated by fakerjsgenerator\n");
    formattedWrite(ltw, "module faked.test;\n\nimport std.array : empty;\n\n");

    string calls = "\tfor(int i = 0; i < 30; ++i) {\n" ~
        methods
            .map!(a => format("\t\tassert(!faker.%s().empty);\n", a))
            .joiner()
            .to!string()
        ~ "\n\t}\n";

    string ut = `unittest {
%s;
    auto faker = new %s(%d);
%s}

`;
    foreach(idx, l; list) {
        formattedWrite(ltw, ut,
            l == "en"
                ? "\timport faked.base"
                : "\timport faked.faker_" ~ toLower(l),
            l == "en" ? "Faker" : "Faker_" ~ toLower(l),
            idx + 1, calls
        );
    }
}

string[] buildFile(string ll, FakerData entry, string[] toOverride) {
	//writeln(f.front);
    string[] methods;
	Generator gen = new Generator(ll, entry.fallback, toOverride);
	foreach(key, value; entry.data) {
		if(ignoreEntries.canFind(key)) {
			continue;
		}
		foreach(sub, svalue; value.subs) {
			Direct d = cast(Direct)svalue;
			if(d !is null) {
                if(key == "name" && sub == "title") {
                    methods ~= gen.buildNameTitle(d.data);
                    continue;
                }
                if(key == "finance" && sub == "currency") {
                    methods ~= gen.buildFinanceCurrency(d.data);
                    continue;
                }
                if(key == "commerce" && sub == "product_name") {
                    methods ~= gen.buildCommerceProductName(d.data);
                    continue;
                }
				//write(key, ".", sub, " ");
				TypeLines tl = jssplit(d.data);
				//writeln(tl.type);
				if(tl.type == Type.strings) {
					methods ~= gen.buildString(key, sub, tl.lines);
				} else if(tl.type == Type.digit) {
					methods ~= gen.buildDigits(key, sub, tl.lines);
				} else if(tl.type == Type.call) {
					methods ~= gen.buildCall(key, sub, tl.lines);
				}
			} else {
                Sub s = cast(Sub)svalue;
                if(key == "finance" && sub == "credit_card" && s !is null) {
                    methods ~= gen.buildCreditCards(s);
                }
            }
		}
	}

    string fname = (ll == "en")
        ? "base.d"
        : "faker_" ~ toLower(ll) ~ ".d";

    if(ll == "en") {
        methods ~= gen.buildIbanAndBic();
        methods ~= ["addressLatitude", "addressLongitude", "fianceAccount",
                "fianceRoutingNumber", "financeMask", "financeBitcoinAddress",
                "loremSentance", "loremSentances", "loremParagraph",
                "loremParagraphs", "loremText", "phoneNumber"];
    }

	gen.finish();

	auto fout = File(outputDir ~ fname, "w");
    auto ltw = fout.lockingTextWriter();
    formattedWrite(ltw, "// generated by fakerjsgenerator\n");
	fout.write(gen.output);

    //return methods.filter!(a => !a.empty).array;
    return methods.sort.array;
}

const fakerFolder = "faker.js";

const string[] ignoreListLocals = ["fa"];
const string[] ignoreEntries = ["system"];

class Data {
	override string toString() const {
		assert(false);
	}
}

class Direct : Data {
	string data;

	this(string d) {
		this.data = d;
	}

	override string toString() const {
		return format("    Direct \n%s", this.data);
	}
}

class Sub : Data {
	string index;
	Direct[string] subs;

	override string toString() const {
		string ret;
		foreach(key, value; subs) {
			ret ~= format("\n            %s", key);
		}
		return ret;
	}
}

struct Entry {
	string index;
	Data[string] subs;

	void toString(scope void delegate(const(char)[]) sink) const {
		foreach(key, const(Data) value; this.subs) {
			formattedWrite(sink, "        %s:%s\n", key, value.toString());
		}
	}
}

class FakerData {
	string locale;
	string fallback;
	Entry[string] data;

	void toString(scope void delegate(const(char)[]) sink) const {
		formattedWrite(sink, "%s fallback %s\n", this.locale, fallback);
		foreach(key, value; this.data) {
			formattedWrite(sink, "    %s:\n", key);
			value.toString(sink);
		}
	}
}

void cloneFaker() {
	import std.file : exists, rmdirRecurse;

	if(exists(fakerFolder)) {
        return;
	}

	auto rslt = executeShell(
            "git clone --depth=1 https://github.com/Marak/faker.js.git"
        );
	enforce(rslt.status == 0,
		format("Failed to clone faker.js with message %s %s", rslt.status,
			rslt.output)
	);
}

FakerData[] scrapeFakers() {
	FakerData[] ret;
	const fakerLocales = fakerFolder ~ "/lib/locales/";

	outer: foreach(f; dirEntries(fakerLocales, SpanMode.shallow)) {
		foreach(ig; ignoreListLocals) {
			if(f.name.endsWith(ig)) {
				continue outer;
			}
		}
		ret ~= scrapeFaker(f.name);
		buildFallback(ret.back);
	}
	return ret;
}

FakerData scrapeFaker(string foldername) {
	auto ret = new FakerData();
	string name = foldername[foldername.lastIndexOf("/") + 1 .. $];
	ret.locale = name;

	foreach(f; dirEntries(foldername, SpanMode.shallow)) {
		Entry entry;
		if(f.name.endsWith("index.js")) {
			string iFile = "./" ~ f.name;
			assert(isFile(iFile));
			entry.index = readText(iFile);
			continue;
		}
		if(isDir(f.name)) {
			foreach(g; dirEntries(f, SpanMode.shallow)
					.filter!(a => !a.name.canFind("index.js")))
			{
				if(isFile(g.name)) {
					string s = g.name;
					s = s[s.lastIndexOf("/") + 1 .. $ - 3];
					entry.subs[s] = new Direct(readText(g.name));
				} else {
					auto sub = new Sub();
					sub.index = readText(g.name ~ "/index.js");
					foreach(h; dirEntries(g.name, SpanMode.shallow)
							.filter!(a => !a.name.canFind("index.js")))
					{
						string sh = h.name;
						sh = sh[sh.lastIndexOf("/") + 1 .. $ - 3];
						if(isFile(h)) {
							//writeln(sh, " ", h);
							sub.subs[sh] = new Direct(readText(h));
						}
					}
					entry.subs[g.name[g.name.lastIndexOf("/") + 1 .. $]] = sub;
				}
			}
		}
		ret.data[f.name[f.name.lastIndexOf("/") + 1 .. $]] = entry;
	}
	return ret;
}

enum r = r"\{\s*locale:\s*'([a-zA-Z_]\+)'\s*,\s*localeFallback\s*:'([a-zA-Z_]\+)'\s*\}";
enum r2 = r"'(\w*)'";
auto re = regex(r2);

void buildFallback(FakerData fd) {
	string t = fakerFolder ~ "/locale/" ~ fd.locale ~ ".js";
	if(!exists(t)) {
		return;
	}

	string[] tt = readText(t).split("\n");
	foreach(l; tt) {
		enum pre = "var faker = new Faker(";
		if(l.startsWith(pre)) {
			string narrow = l[pre.length .. $ - 2];
			auto m = matchAll(narrow, re);
			if(!m.empty) {
				string f = m.front.hit.strip("'");
				assert(f == fd.locale,
					format("%s %s", fd.locale, f)
				);
				m.popFront();
				f = m.front.hit.strip("'");
				if(!m.empty) {
					fd.fallback = f;
				}
			}
		}
	}
}