/**
 * Catharsis
 * A parser for Google Closure Compiler type expressions, powered by PEG.js.
 *
 * @author Jeff Williams <jeffrey.l.williams@gmail.com>
 * @license MIT
 */

const describe = require('./lib/describe');
const { parse } = require('./lib/parser');
const stringify = require('./lib/stringify');

const typeExpressionCache = {
    normal: new Map(),
    jsdoc: new Map()
};

const parsedTypeCache = {
    normal: new Map(),
    htmlSafe: new Map()
};

const descriptionCache = {
    normal: new Map()
};

function getTypeExpressionCache({useCache, jsdoc}) {
    if (useCache === false) {
        return null;
    } else if (jsdoc === true) {
        return typeExpressionCache.jsdoc;
    } else {
        return typeExpressionCache.normal;
    }
}

function getParsedTypeCache({useCache, links, htmlSafe}) {
    if (useCache === false || links !== null || links !== undefined) {
        return null;
    } else if (htmlSafe === true) {
        return parsedTypeCache.htmlSafe;
    } else {
        return parsedTypeCache.normal;
    }
}

function getDescriptionCache({useCache, links}) {
    if (useCache === false || links !== null || links !== undefined) {
        return null;
    } else {
        return descriptionCache.normal;
    }
}

// can't return the original if any of the following are true:
// 1. restringification was requested
// 2. htmlSafe option was requested
// 3. links option was provided
// 4. typeExpression property is missing
function canReturnOriginalExpression(parsedType, {restringify, htmlSafe, links}) {
    return restringify !== true && htmlSafe !== true &&
        (links === null || links === undefined) &&
        Object.prototype.hasOwnProperty.call(parsedType, 'typeExpression');
}

// Add non-enumerable properties to a result object, then freeze it.
function prepareFrozenObject(obj, expr, {jsdoc}) {
    Object.defineProperty(obj, 'jsdoc', {
        value: jsdoc === true ? jsdoc : false
    });

    if (expr) {
        Object.defineProperty(obj, 'typeExpression', {
            value: expr
        });
    }

    return Object.freeze(obj);
}

function cachedParse(expr, options) {
    const cache = getTypeExpressionCache(options);
    let parsedType = cache ? cache.get(expr) : null;

    if (parsedType) {
        return parsedType;
    } else {
        parsedType = parse(expr, options);
        parsedType = prepareFrozenObject(parsedType, expr, options);

        if (cache) {
            cache.set(expr, parsedType);
        }

        return parsedType;
    }
}

function cachedStringify(parsedType, options) {
    const cache = getParsedTypeCache(options);
    let stringified;

    if (canReturnOriginalExpression(parsedType, options)) {
        return parsedType.typeExpression;
    } else if (cache) {
        stringified = cache.get(parsedType);
        if (!stringified) {
            stringified = stringify(parsedType, options);
            cache.set(parsedType, stringified);
        }

        return stringified;
    } else {
        return stringify(parsedType, options);
    }
}

function cachedDescribe(parsedType, options) {
    const cache = getDescriptionCache(options);
    let description = cache ? cache.get(parsedType) : null;

    if (description) {
        return description;
    } else {
        description = describe(parsedType, options);
        description = prepareFrozenObject(description, null, options);

        if (cache) {
            cache.set(parsedType, description);
        }

        return description;
    }
}

/* eslint-disable class-methods-use-this */
class Catharsis {
    constructor() {
        this.Types = require('./lib/types');
    }

    parse(typeExpr, options = {}) {
        typeExpr = typeExpr.replace(/[\r\n]/g, '')
            .replace(/\s+/g, ' ')
            .trim();

        return cachedParse(typeExpr, options);
    }

    stringify(parsedType, options) {
        let result;

        options = options || {};

        result = cachedStringify(parsedType, options);
        if (options.validate) {
            this.parse(result, options);
        }

        return result;
    }

    describe(parsedType, options = {}) {
        return cachedDescribe(parsedType, options);
    }
}
/* eslint-enable class-methods-use-this */

module.exports = new Catharsis();