'use strict';

const drvParser = require("./drv");

function valueType(value) {
	if (typeof value === "string") {
		return "string";
	} else {
		return value.type;
	}
}

function assertType(value, expectedType) {
	if (valueType(value) == null) {
		throw new Error(`Expected a '${expectedType}', got nothing`);
	} else if (valueType(value) !== expectedType) {
		throw new Error(`Expected a '${expectedType}', got '${valueType(value)}'`);
	} else {
		return true;
	}
}

function assertedValue(type, value) {
	if (assertType(value, type)) {
		return value;
	}
}

function mapArray(array, callback) {
	return assertedValue("array", array).items.map(callback);
}

function mapTuple(tuple, fields, callback) {
	return assertedValue("tuple", tuple).items.reduce((result, item, i) => {
		if (fields[i] != null) {
			let value;

			if (callback != null) {
				value = callback(item, i);
			} else {
				value = item;
			}

			result[fields[i]] = value;
			return result;
		} else {
			throw new Error(`Attempted to map field ${i}, but only ${fields.length} field names were specified`);
		}
	}, {});
}

function parseDerivation(text) {
	let root = parseAST(text);

	return {
		outputs: mapArray(root.items[0], (item) => {
			return mapTuple(item, ["name", "path", "expectedHashAlgorithm", "expectedHash"]);
		}),
		inputDerivations: mapArray(root.items[1], (item) => {
			return mapTuple(item, ["path", "wantedOutputs"], (value, i) => {
				if (i === 1) {
					/* An `array` of outputs */
					return value.items;
				} else {
					return value;
				}
			});
		}),
		inputSources: assertedValue("array", root.items[2]).items,
		platform: assertedValue("string", root.items[3]),
		builder: assertedValue("string", root.items[4]),
		builderArguments: assertedValue("array", root.items[5]).items,
		environmentVariables: mapArray(root.items[6], (item) => {
			return mapTuple(item, ["name", "value"]);
		})
	}
};

function parseAST(text) {
	return drvParser.parse(text);
}

parseDerivation.ast = parseAST;
module.exports = parseDerivation;