import { Pattern, NamedPattern, Schema, Input, Environment, Ref, lookup } from "./meta";
import * as M from './meta';
import { Annotated, Bytes, Dictionary, Fold, fold, KeyedSet, Position, preserves, Record, Set, Tuple, Value } from "@preserves/core";
import { Formatter, parens, seq, Item, opseq, block, commas, brackets, anglebrackets, braces } from "./block";
import { refPosition } from "./reader";

export interface CompilerOptions {
    preservesModule?: string;
    defaultPointer?: Ref;
    warn?(message: string, pos: Position | null): void;
};

function fnblock(... items: Item[]): Item {
    return seq('((() => ', block(... items), ')())');
}

export function compile(env: Environment, schema: Schema, options: CompilerOptions = {}): string {
    const literals = new Dictionary<string, never>();
    const types: Array<Item> = [];
    const functions: Array<Item> = [];
    const imports = new KeyedSet<[string, string]>();
    let temps: Array<string> = [];
    const pointerName = Schema._.details(schema).get(M.$pointer);

    function applyPredicate(name: Ref, v: string): Item {
        return lookup(refPosition(name), name, env,
                      (_p) => `is${Ref._.name(name).description!}(${v})`,
                      (p) => walk(v, p),
                      (mod, modPath, _p) => {
                          imports.add([mod, modPath]);
                          return `${mod}.is${Ref._.name(name).description!}(${v})`;
                      });
    }

    function gentemp(): string {
        const varname = '_tmp' + temps.length;
        temps.push(varname);
        return varname;
    }

    function literal(v: Input): Item {
        let varname = literals.get(v);
        if (varname === void 0) {
            const s = v.asPreservesText()
                .replace('_', '__')
                .replace('*', '_STAR_');
            varname = M.isValidToken('_' + s, true) ? '$' + s : '__lit' + literals.size;
            literals.set(v, varname);
        }
        return varname;
    }

    function typeFor(p: Pattern): Item {
        switch (p.label) {
            case M.$atom:
                switch (p[0]) {
                    case M.$Boolean: return `boolean`;
                    case M.$Float: return `_.SingleFloat`;
                    case M.$Double: return `_.DoubleFloat`;
                    case M.$SignedInteger: return `number`;
                    case M.$String: return `string`;
                    case M.$ByteString: return `_.Bytes`;
                    case M.$Symbol: return `symbol`;
                }
            case M.$lit:
                return `(typeof ${literal(p[0])})`;
            case M.$ref:
                return lookup(refPosition(p), p, env,
                              (_p) => p[1].description!,
                              (p) => typeFor(p),
                              (mod, modPath,_p) => {
                                  imports.add([mod, modPath]);
                                  return `${mod}.${p[1].description!}`;
                              });
            case M.$or:
                return opseq('never', ' | ', ... p[0].map(pp => typeFor(pp)));
            case M.$and:
                return opseq('_val', ' & ', ... p[0].map(pp => typeFor(pp)));
            case M.$pointer:
                return `_ptr`;
            case M.$rec:
                return seq('_.Record', anglebrackets(typeFor(p[0]), typeFor(p[1]), '_ptr'));
            case M.$tuple:
                return brackets(... p[0].map(pp => typeFor(unname(pp))));
            case M.$tuple_STAR_:
                if (p[0].length === 0) {
                    return seq('Array<', typeFor(unname(p[1])), '>');
                } else {
                    return brackets(... p[0].map(pp => typeFor(unname(pp))),
                                    seq('... Array<', typeFor(unname(p[1])), '>'));
                }
            case M.$setof:
                return seq('_.KeyedSet<', typeFor(p[0]), '>');
            case M.$dictof:
                return seq('_.KeyedDictionary', anglebrackets(typeFor(p[0]), typeFor(p[1])));
            case M.$dict:
                return parens(seq(
                    block(
                        ... Array.from(p[0]).map(([k, vp]) =>
                            seq(`get(k: typeof ${literal(k)}): `, typeFor(vp))),
                        ... Array.from(p[0]).map(([k, _vp]) =>
                            seq(`has(k: typeof ${literal(k)}): true`))),
                    ' & _.Dictionary<_val, _ptr>'));
            default:
                ((_p: never) => {})(p);
                throw new Error("Unreachable");
        }
    }

    function walk(v: string, p: Pattern, recordOkAsTuple = false): Item {
        switch (p.label) {
            case M.$atom:
                switch (p[0]) {
                    case M.$Boolean: return `typeof ${v} === 'boolean'`;
                    case M.$Float: return `_.Float.isSingle(${v})`;
                    case M.$Double: return `_.Float.isDouble(${v})`;
                    case M.$SignedInteger: return `typeof ${v} === 'number'`;
                    case M.$String: return `typeof ${v} === 'string'`;
                    case M.$ByteString: return `_.Bytes.isBytes(${v})`;
                    case M.$Symbol: return `typeof ${v} === 'symbol'`;
                }
            case M.$lit:
                return `_.is(${v}, ${literal(p[0])})`;
            case M.$ref:
                return applyPredicate(p, v);
            case M.$or:
                return opseq('false', ' || ', ... p[0].map(pp => walk(v, pp)));
            case M.$and:
                return opseq('true', ' && ', ... p[0].map(pp => walk(v, pp)));
            case M.$pointer:
                return `_.isPointer(${v})`;
            case M.$rec:
                return opseq('true', ' && ',
                             `_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(${v})`,
                             walk(`${v}.label`, p[0]),
                             walk(v, p[1], true));
            case M.$tuple:
                return opseq('true', ' && ',
                             ... (recordOkAsTuple ? []
                                 : [`_.Array.isArray(${v})`, `!_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(${v})`]),
                             `(${v}.length === ${p[0].length})`,
                             ... p[0].map((pp, i) => walk(`${v}[${i}]`, unname(pp))));
            case M.$tuple_STAR_:
                return opseq('true', ' && ',
                             ... (recordOkAsTuple ? []
                                 : [`_.Array.isArray(${v})`, `!_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(${v})`]),
                             `(${v}.length >= ${p[0].length})`,
                             seq(`${v}.slice(${p[0].length})`,
                                 `.every(v => `,
                                 parens(walk('v', unname(p[1]))),
                                 `)`),
                             ... p[0].map((pp, i) => walk(`${v}[${i}]`, unname(pp))));
            case M.$setof:
                return opseq('true', ' && ',
                             `_.Set.isSet<_val>(${v})`,
                             fnblock(
                                 seq(`for (const vv of ${v}) `, block(
                                     seq('if (!(', walk('vv', p[0]), ')) return false'))),
                                 seq('return true')));
            case M.$dictof:
                return opseq('true', ' && ',
                             `_.Dictionary.isDictionary<_val, _ptr>(${v})`,
                             fnblock(
                                 seq(`for (const e of ${v}) `, block(
                                     seq('if (!(', walk('e[0]', p[0]), ')) return false'),
                                     seq('if (!(', walk('e[1]', p[1]), ')) return false'))),
                                 seq('return true')));
            case M.$dict:
                return opseq('true', ' && ',
                             `_.Dictionary.isDictionary<_val, _ptr>(${v})`,
                             ... Array.from(p[0]).map(([k, vp]) => {
                                 const tmp = gentemp();
                                 return parens(seq(
                                     `(${tmp} = ${v}.get(${literal(k)})) !== void 0 && `,
                                     walk(tmp, vp)));
                             }));
            default:
                ((_p: never) => {})(p);
                throw new Error("Unreachable");
        }
    }

    function unname(p: NamedPattern): Pattern {
        return (p.label === M.$named) ? p[1] : p;
    }

    function fieldName(np: NamedPattern, index: number): string {
        return (np.label === M.$named) ? np[0].description! : `_field${index}`;
    }

    function fieldEntry(np: NamedPattern, index: number): Item {
        return seq(JSON.stringify(fieldName(np, index)), ': ', typeFor(unname(np)));
    }

    for (const [name0, pattern] of Schema._.details(schema).get(M.$definitions)) {
        const name = name0 as symbol;
        temps = [];
        const recognizer = walk('v', pattern);
        if (pattern.label === M.$rec &&
            pattern[0].label === M.$lit &&
            pattern[1].label === M.$tuple)
        {
            types.push(
                seq(`export const ${name.description!} = _.Record.makeConstructor<`,
                    braces(... pattern[1][0].map(fieldEntry)),
                    `, _ptr>()(${literal(pattern[0][0])}, `,
                    JSON.stringify(pattern[1][0].map(fieldName)), `);`));
        }
        types.push(
            seq(`export type ${name.description!} = `, typeFor(pattern), `;`));
        functions.push(
            seq('export function ', `is${name.description!}`,
                '(v: any): v is ', name.description!, ' ',
                block(
                    ... temps.length > 0 ? [seq('let ', commas(... temps), ': any')] : [],
                    seq('return ', recognizer))));
        functions.push(
            seq('export function ', `as${name.description!}`,
                '(v: any): ', name.description!, ' ',
                block(
                    seq(`if (!is${name.description!}(v)) `,
                        block(`throw new TypeError(\`Invalid ${name.description!}: \${_.stringify(v)}\`)`),
                        ' else ',
                        block(`return v`)))));
    }

    types.push(seq('export type _ptr = ', pointerName === false ? 'never' : typeFor(pointerName), `;`));
    types.push(`export type _val = _.Value<_ptr>;`);

    const f = new Formatter();
    f.write(`import * as _ from ${JSON.stringify(options.preservesModule ?? '@preserves/core')};\n`);
    imports.forEach(([identifier, path]) => {
        f.write(`import * as ${identifier} from ${JSON.stringify(path)};\n`);
    });
    f.newline();

    const sortedLiterals = Array.from(literals);
    sortedLiterals.sort((a, b) => a[1] < b[1] ? -1 : a[1] === b[1] ? 0 : 1);
    for (const [lit, varname] of sortedLiterals) {
        f.write(seq(`export const ${varname} = `, sourceCodeFor(lit), `;\n`));
    }
    f.newline();

    types.forEach(t => {
        f.write(t);
        f.newline();
        f.newline();
    });
    f.newline();

    functions.forEach(p => {
        f.write(p);
        f.newline();
        f.newline();
    });

    return f.toString();
}

export function stringSource(s: string) {
    return JSON.stringify(s);
}

export function sourceCodeFor(v: Value<any>): Item {
    return fold(v, {
        boolean(b: boolean): Item { return b.toString(); },
        single(f: number): Item { return f.toString(); },
        double(f: number): Item { return f.toString(); },
        integer(i: number): Item { return i.toString(); },
        string(s: string): Item { return stringSource(s); },
        bytes(b: Bytes): Item {
            return seq(`Uint8Array.from(`, brackets(... Array.from(b).map(b => b.toString())), `)`);
        },
        symbol(s: symbol): Item { return `Symbol.for(${stringSource(s.description!)})`; },

        record(r: Record<Value<any>, Tuple<Value<any>>, any>, k: Fold<any, Item>): Item {
            return seq(`_.Record<_val, _.Tuple<_val>, _ptr>`, parens(k(r.label), brackets(... r.map(k))));
        },
        array(a: Array<Value<any>>, k: Fold<any, Item>): Item {
            return brackets(... a.map(k));
        },
        set(s: Set<any>, k: Fold<any, Item>): Item {
            return seq('new _.Set<_val>', parens(brackets(... Array.from(s).map(k))));
        },
        dictionary(d: Dictionary<Value<any>, any>, k: Fold<any, Item>): Item {
            return seq('new _.Dictionary<_val, _ptr>', parens(brackets(... Array.from(d).map(([kk,vv]) =>
                brackets(k(kk), k(vv))))));
        },

        annotated(a: Annotated<any>, k: Fold<any, Item>): Item {
            return seq('_.annotate<_ptr>', parens(k(a.item), ... a.annotations.map(k)));
        },

        pointer(t: any, _k: Fold<any, Item>): Item {
            throw new Error(preserves`Cannot emit source code for construction of pointer ${t}`);
        },
    });
}