'use strict';

const fs = require('fs');
const path = require('path');
const winston = require('winston');
const _ = require('lodash');
const nconf = require('nconf');

const db = require('../database');
const file = require('../file');
const { paths } = require('../constants');

const Data = module.exports;

const basePath = path.join(__dirname, '../../');

// to get this functionality use `plugins.getActive()` from `src/plugins/install.js` instead
// this method duplicates that one, because requiring that file here would have side effects
async function getActiveIds() {
	if (nconf.get('plugins:active')) {
		return nconf.get('plugins:active');
	}
	return await db.getSortedSetRange('plugins:active', 0, -1);
}

Data.getPluginPaths = async function () {
	const plugins = await getActiveIds();
	const pluginPaths = plugins.filter(plugin => plugin && typeof plugin === 'string')
		.map(plugin => path.join(paths.nodeModules, plugin));
	const exists = await Promise.all(pluginPaths.map(file.exists));
	exists.forEach((exists, i) => {
		if (!exists) {
			winston.warn(`[plugins] "${plugins[i]}" is active but not installed.`);
		}
	});
	return pluginPaths.filter((p, i) => exists[i]);
};

Data.loadPluginInfo = async function (pluginPath) {
	const [packageJson, pluginJson] = await Promise.all([
		fs.promises.readFile(path.join(pluginPath, 'package.json'), 'utf8'),
		fs.promises.readFile(path.join(pluginPath, 'plugin.json'), 'utf8'),
	]);

	let pluginData;
	let packageData;
	try {
		pluginData = JSON.parse(pluginJson);
		packageData = JSON.parse(packageJson);

		pluginData.license = parseLicense(packageData);

		pluginData.id = packageData.name;
		pluginData.name = packageData.name;
		pluginData.description = packageData.description;
		pluginData.version = packageData.version;
		pluginData.repository = packageData.repository;
		pluginData.nbbpm = packageData.nbbpm;
		pluginData.path = pluginPath;
	} catch (err) {
		const pluginDir = path.basename(pluginPath);

		winston.error(`[plugins/${pluginDir}] Error in plugin.json or package.json!${err.stack}`);
		throw new Error('[[error:parse-error]]');
	}
	return pluginData;
};

function parseLicense(packageData) {
	try {
		const licenseData = require(`spdx-license-list/licenses/${packageData.license}`);
		return {
			name: licenseData.name,
			text: licenseData.licenseText,
		};
	} catch (e) {
		// No license matched
		return null;
	}
}

Data.getActive = async function () {
	const pluginPaths = await Data.getPluginPaths();
	return await Promise.all(pluginPaths.map(p => Data.loadPluginInfo(p)));
};


Data.getStaticDirectories = async function (pluginData) {
	const validMappedPath = /^[\w\-_]+$/;

	if (!pluginData.staticDirs) {
		return;
	}

	const dirs = Object.keys(pluginData.staticDirs);
	if (!dirs.length) {
		return;
	}

	const staticDirs = {};

	async function processDir(route) {
		if (!validMappedPath.test(route)) {
			winston.warn(`[plugins/${pluginData.id}] Invalid mapped path specified: ${
				route}. Path must adhere to: ${validMappedPath.toString()}`);
			return;
		}
		const dirPath = await resolveModulePath(pluginData.path, pluginData.staticDirs[route]);
		if (!dirPath) {
			winston.warn(`[plugins/${pluginData.id}] Invalid mapped path specified: ${
				route} => ${pluginData.staticDirs[route]}`);
			return;
		}
		try {
			const stats = await fs.promises.stat(dirPath);
			if (!stats.isDirectory()) {
				winston.warn(`[plugins/${pluginData.id}] Mapped path '${
					route} => ${dirPath}' is not a directory.`);
				return;
			}

			staticDirs[`${pluginData.id}/${route}`] = dirPath;
		} catch (err) {
			if (err.code === 'ENOENT') {
				winston.warn(`[plugins/${pluginData.id}] Mapped path '${
					route} => ${dirPath}' not found.`);
				return;
			}
			throw err;
		}
	}

	await Promise.all(dirs.map(route => processDir(route)));
	winston.verbose(`[plugins] found ${Object.keys(staticDirs).length} static directories for ${pluginData.id}`);
	return staticDirs;
};


Data.getFiles = async function (pluginData, type) {
	if (!Array.isArray(pluginData[type]) || !pluginData[type].length) {
		return;
	}

	winston.verbose(`[plugins] Found ${pluginData[type].length} ${type} file(s) for plugin ${pluginData.id}`);

	return pluginData[type].map(file => path.join(pluginData.id, file));
};

/**
 * With npm@3, dependencies can become flattened, and appear at the root level.
 * This method resolves these differences if it can.
 */
async function resolveModulePath(basePath, modulePath) {
	const isNodeModule = /node_modules/;

	const currentPath = path.join(basePath, modulePath);
	const exists = await file.exists(currentPath);
	if (exists) {
		return currentPath;
	}
	if (!isNodeModule.test(modulePath)) {
		winston.warn(`[plugins] File not found: ${currentPath} (Ignoring)`);
		return;
	}

	const dirPath = path.dirname(basePath);
	if (dirPath === basePath) {
		winston.warn(`[plugins] File not found: ${currentPath} (Ignoring)`);
		return;
	}

	return await resolveModulePath(dirPath, modulePath);
}


Data.getScripts = async function getScripts(pluginData, target) {
	target = (target === 'client') ? 'scripts' : 'acpScripts';

	const input = pluginData[target];
	if (!Array.isArray(input) || !input.length) {
		return;
	}

	const scripts = [];

	for (const filePath of input) {
		/* eslint-disable no-await-in-loop */
		const modulePath = await resolveModulePath(pluginData.path, filePath);
		if (modulePath) {
			scripts.push(modulePath);
		}
	}
	if (scripts.length) {
		winston.verbose(`[plugins] Found ${scripts.length} js file(s) for plugin ${pluginData.id}`);
	}
	return scripts;
};


Data.getModules = async function getModules(pluginData) {
	if (!pluginData.modules || !pluginData.hasOwnProperty('modules')) {
		return;
	}

	let pluginModules = pluginData.modules;

	if (Array.isArray(pluginModules)) {
		const strip = parseInt(pluginData.modulesStrip, 10) || 0;

		pluginModules = pluginModules.reduce((prev, modulePath) => {
			let key;
			if (strip) {
				key = modulePath.replace(new RegExp(`.?(/[^/]+){${strip}}/`), '');
			} else {
				key = path.basename(modulePath);
			}

			prev[key] = modulePath;
			return prev;
		}, {});
	}

	const modules = {};
	async function processModule(key) {
		const modulePath = await resolveModulePath(pluginData.path, pluginModules[key]);
		if (modulePath) {
			modules[key] = path.relative(basePath, modulePath);
		}
	}

	await Promise.all(Object.keys(pluginModules).map(key => processModule(key)));

	const len = Object.keys(modules).length;
	winston.verbose(`[plugins] Found ${len} AMD-style module(s) for plugin ${pluginData.id}`);
	return modules;
};

Data.getLanguageData = async function getLanguageData(pluginData) {
	if (typeof pluginData.languages !== 'string') {
		return;
	}

	const pathToFolder = path.join(paths.nodeModules, pluginData.id, pluginData.languages);
	const filepaths = await file.walk(pathToFolder);

	const namespaces = [];
	const languages = [];

	filepaths.forEach((p) => {
		const rel = path.relative(pathToFolder, p).split(/[/\\]/);
		const language = rel.shift().replace('_', '-').replace('@', '-x-');
		const namespace = rel.join('/').replace(/\.json$/, '');

		if (!language || !namespace) {
			return;
		}

		languages.push(language);
		namespaces.push(namespace);
	});
	return {
		languages: _.uniq(languages),
		namespaces: _.uniq(namespaces),
	};
};