// Local Imports
let Client = require(`../App.js`)

// NPM Imports
const fs = require("fs-extra-promise");
const klaw = require("klaw");
const path = require("path");

class Loader {

	constructor(client) {
		this.Client = client;
	}

	async getFiles(type) {
		return new Promise(async (resolve, reject) => {
			let dir = path.join(__dirname, "../", type);
			await fs.ensureDirAsync(dir).catch(err => this.Client.utils.Logger.error(err));
			return resolve(this.loadFiles(dir).catch(err => this.Client.utils.Logger.error(err)));
		});
	}

	async loadFiles(dir) {
		return new Promise(async (resolve, reject) => {
			let files = [];
			try {
				klaw(dir).on("data", item => {
					let fileInfo = path.parse(item.path);
					if (!fileInfo.ext || fileInfo.ext !== ".js") return;
					files.push(fileInfo);
				}).on("end", () => {
					resolve(files)
				}).on("errors", (root, nodeStatsArray, next) => {
					nodeStatsArray.forEach(n => Logger.error(`${n.name} - ${n.error.message}` || `${n.name} - ${n.error.code}: ${n.error.path}`));
					next();
				});
			}
			catch (err) { reject(err); };
		});
	}

	async load(type, item, file) {
		return new Promise(async (resolve, reject) => {
			if (!file) {
				let files = await this.getFiles(type).catch(err => this.Client.utils.Logger.error(err));
				file = files.filter(f => f.name === item);
			}
			if (!file || !fs.existsSync(file)) reject("fileNotFound");
			let i = require(file);
			if (!this.Client.collections[type]) this.Client.collections[type] = new this.Client.utils.Collection();
			this.Client.collections[type].set(item, i);
			if (!this.Client.count[type]) this.Client.count[type] = 0;
			this.Client.count[type]++;
			if (this.Client.debug) this.Client.utils.Logger.debug(`Loaded: ${type.slice(0, -1)} "${item}" at "${file}"`);
			if (type === "commands") {
				i.conf.aliases = i.conf.aliases || [];
				let f = file.split(path.sep);
				f = f.slice(f.indexOf("commands") + 1);
				i.conf.aliases.forEach(alias => this.Client.aliases.set(alias, i));
			}
			if (type === "events") {
				let event = (...args) => this.Client.events.get(item).run(this.Client, ...args);
				this.Client.client.on(item, event);
			}
			delete require.cache[require.resolve(file)];
			return resolve();
		});
	}

	async loadAll(type) {
		return new Promise(async (resolve, reject) => {
			let files = await this.getFiles(type);
			files.forEach(f => this.load(type, f.name, `${f.dir}${path.sep}${f.base}`).catch(err => this.Client.utils.Logger.error(err)));
		});
	}

	async loadEverything(things) {
		return new Promise(async (resolve, reject) => {
			if (!things) things = ["commands", "events", "functions", "handlers", "models"];
			things.forEach(t => this.loadAll(t).catch(e => this.Client.utils.Logger.error(e)));
		});
	}

	async unload(type, item) {
		return new Promise(async (resolve, reject) => {
			if (type === "commands") {
				client.commands_aliases.forEach((cmd, alias) => { if (cmd === item) client.commands_aliases.delete(alias); });
			}
			if (type === "events") {
				client.client.removeListener(item);
			}
			if (!client[type].has(item)) reject("itemNotFound");
			client[type].delete(item);
			return resolve();
		});
	}
}

module.exports = Loader;