import { isPrimitive, isNull, each } from "../safe";
import { MapOf } from "../interfaces";

type SubstFn = (name: string, format?: string) => string;
type TemplateFn = (subst: SubstFn) => string;
type ConvertFn = (value: any, format?: string) => string;

const map = {
    "\\{": "&curlopen;",
    "\\}": "&curlclose;",
    "&": "&",
    "\\:": ":"
};

const rev = {
    curlopen: "{",
    curlclose: "}",
    amp: "&",
    colon: ":"
};

function espaceString(s: string) {
    if (!s)
        return s;
    return "'" + s.replace(/('|\\)/g, "\\$1").replace("\n", "\\n") + "'";
}

function encode(s: string) {
    if (!s)
        return s;
    return s.replace(/\\{|\\}|&|\\:|\n/g, m => map[m] || m);
}

function decode(s: string) {
    if (!s)
        return s;
    return s.replace(/&(\w+);/g, (m, $1) => rev[$1] || m);
}

function subst(s: string) {
    const i = s.indexOf(":");
    let name: string;
    let pattern: string;
    if (i >= 0) {
        name = s.substr(0, i);
        pattern = s.substr(i + 1);
    } else {
        name = s;
    }

    if (pattern)
        return [
            espaceString(decode(name)),
            espaceString(decode(pattern))];
    else
        return [espaceString(decode(name))];
}

function _compile(str: string) {
    if (!str)
        return () => void 0;

    const chunks = encode(str).split("{");
    let chunk: string;

    const code = ["var result=[];"];

    for (let i = 0; i < chunks.length; i++) {
        chunk = chunks[i];

        if (i === 0) {
            if (chunk)
                code.push("result.push(" + espaceString(decode(chunk)) +
                    ");");
        } else {
            const len = chunk.indexOf("}");
            if (len < 0)
                throw new Error("Unbalanced substitution #" + i);

            code.push("result.push(subst(" +
                subst(chunk.substr(0, len)).join(",") + "));");
            if (chunk.length > len + 1)
                code.push("result.push(" +
                    espaceString(decode(chunk.substr(len + 1))) + ");");
        }
    }

    code.push("return result.join('');");

    // the code for this function is generated from the template
    // tslint:disable-next-line:function-constructor
    return new Function("subst", code.join("\n")) as TemplateFn;
}

const cache: MapOf<TemplateFn> = {};

export function compile(template: string) {
    let compiled = cache[template];
    if (!compiled) {
        compiled = _compile(template);
        cache[template] = compiled;
    }
    return compiled;
}

function defaultConverter(value: any, pattern: string) {
    if (pattern && pattern.toLocaleLowerCase() === "json") {
        const seen = [];
        return JSON.stringify(value, (k, v) => {
            if (!isPrimitive(v)) {
                const id = seen.indexOf(v);
                if (id >= 0)
                    return "@ref-" + id;
                else {
                    seen.push(v);
                    return v;
                }
            } else {
                return v;
            }
        }, 2);
    } else if (isNull(value)) {
        return "";
    } else if (value instanceof Date) {
        return value.toISOString();
    } else {
        return pattern ? value.toString(pattern) : value.toString();
    }
}

export class Formatter {
    _converters: ConvertFn[];

    constructor(converters?: ConvertFn[]) {
        this._converters = converters || [];
        this._converters.push(defaultConverter);
    }

    convert(value: any, pattern: string) {
        for (const c of this._converters) {
            const res = c(value, pattern);
            if (!isNull(res))
                return res;
        }
        return "";
    }

    format(msg: string, ...args: any[]) {
        const template = compile(msg);

        return template((name, pattern) => {
            const value = args[name];
            return !isNull(value) ? this.convert(value, pattern) : "";
        });

    }

    compile(msg: string) {
        const template = compile(msg);
        return (...args: any[]) => {
            return template((name, pattern) => {
                const value = args[name];
                return !isNull(value) ? this.convert(value, pattern) : "";
            });
        };
    }
}

const _default = new Formatter();

export function format(msg: string, ...args: any[]) {
    return _default.format(msg, ...args);
}