import { Reader, Annotated, Dictionary, is, peel, preserves, Record, strip, Tuple, Position, position, ReaderOptions, stringify, isCompound, KeyedDictionary } from '@preserves/core';
import { Input, Pattern, Schema, Alternative, Definition, CompoundPattern, SimplePattern } from './meta';
import * as M from './meta';
import { SchemaSyntaxError } from './error';

const positionTable = new WeakMap<object, Position>();

export function recordPosition<X extends object>(v: X, pos: Position | null): X {
    if (pos === null) { console.error('Internal error in Schema reader: null source position for', v); }
    if (pos !== null) positionTable.set(v, pos);
    return v;
}

export function refPosition(v: object): Position | null {
    return positionTable.get(v) ?? null;
}

function splitBy<T>(items: Array<T>, separator: T): Array<Array<T>> {
    const groups: Array<Array<T>> = [];
    let group: Array<T> = [];
    function finish() {
        if (group.length > 0) {
            groups.push(group);
            group = [];
        }
    }
    for (const item of items) {
        if (is(item, separator)) {
            finish();
        } else {
            group.push(item);
        }
    }
    finish();
    return groups;
}

function invalidClause(clause: Array<Input>): never {
    throw new SchemaSyntaxError(preserves`Invalid Schema clause: ${clause}`,
                                position(clause[0] ?? false));
}

function invalidPattern(name: string, item: Input, pos: Position | null): never {
    throw new SchemaSyntaxError(`Invalid pattern in ${name}: ${stringify(item)}`, pos);
}

export type SchemaReaderOptions = {
    readInclude?(includePath: string): string;
};

function _readSchema(source: string, options?: ReaderOptions<never>): Array<Input> {
    return new Reader<any>(source, {
        ... options ?? {},
        includeAnnotations: true
    }).readToEnd();
}

export function readSchema(source: string,
                           options?: ReaderOptions<never> & SchemaReaderOptions): Schema
{
    return parseSchema(_readSchema(source, options), options ?? {});
}

export function parseSchema(toplevelTokens: Array<Input>,
                            options: ReaderOptions<never> & SchemaReaderOptions): Schema
{
    let version: M.Version | undefined = void 0;
    let embeddedType: M.EmbeddedTypeName = M.EmbeddedTypeName.$false();
    let definitions = new KeyedDictionary<symbol, Definition, M._embedded>();

    function process(toplevelTokens: Array<Input>): void {
        const toplevelClauses = splitBy(peel(toplevelTokens) as Array<Input>, M.DOT);
        for (const clause of toplevelClauses) {
            if (!Array.isArray(clause)) {
                invalidClause(clause);
            } else if (clause.length >= 2 && is(clause[1], M.EQUALS)) {
                const pos = position(clause[0]);
                const name = peel(clause[0]);
                if (typeof name !== 'symbol') invalidClause(clause);
                if (!M.isValidToken(name.description!)) {
                    throw new SchemaSyntaxError(preserves`Invalid definition name: ${name}`, pos);
                }
                if (definitions.has(name)) {
                    throw new SchemaSyntaxError(preserves`Duplicate definition: ${clause}`, pos);
                }
                definitions.set(name, parseDefinition(name, pos, clause.slice(2)));
            } else if (clause.length === 2 && is(clause[0], M.$version)) {
                version = M.asVersion(peel(clause[1]));
            } else if (clause.length === 2 && is(clause[0], M.$embeddedType)) {
                const pos = position(clause[1]);
                const stx = peel(clause[1]);
                if (stx === false) {
                    embeddedType = M.EmbeddedTypeName.$false();
                } else if (typeof stx === 'symbol') {
                    embeddedType = M.EmbeddedTypeName.Ref(parseRef(stx.description!, pos));
                } else {
                    invalidPattern('embedded type name specification', stx, pos);
                }
            } else if (clause.length === 2 && is(clause[0], M.INCLUDE)) {
                const pos = position(clause[1]);
                const path = peel(clause[1]);
                if (typeof path !== 'string') {
                    throw new SchemaSyntaxError(preserves`Invalid include: ${clause}`, pos);
                }
                if (options.readInclude === void 0) {
                    throw new SchemaSyntaxError(preserves`Cannot include files in schema`, pos);
                }
                process(_readSchema(options.readInclude(path), options));
            } else {
                invalidClause(clause);
            }
        }
    }

    process(toplevelTokens);

    if (version === void 0) {
        throw new SchemaSyntaxError("Schema: missing version declaration.", null);
    }

    return M.Schema({ version: M.Version(), embeddedType, definitions });
}

function namedMustBeSimple(p: Position | null): never {
    throw new SchemaSyntaxError('Named patterns must be Simple patterns', p);
}

function parseDefinition(name: symbol, pos: Position | null, body: Array<Input>): Definition {
    let nextAnonymousAlternativeNumber = 0;
    function alternativeName([input, p]: readonly [Array<Input>, Alternative])
    : M.NamedAlternative
    {
        const n = findName(input) || findName(input[0]);
        if (n !== false) {
            return M.NamedAlternative({ variantLabel: n.description!, alternative: p });
        }
        if (p._variant === 'Pattern' &&
            p.value._variant === 'CompoundPattern' &&
            p.value.value._variant === 'rec' &&
            p.value.value.label._variant === 'anonymous' &&
            p.value.value.label.value._variant === 'SimplePattern' &&
            p.value.value.label.value.value._variant === 'lit' &&
            typeof p.value.value.label.value.value.value === 'symbol')
        {
            return M.NamedAlternative({
                variantLabel: p.value.value.label.value.value.value.description!,
                alternative: p
            });
        }
        if (p._variant === 'Pattern' &&
            p.value._variant === 'SimplePattern' &&
            p.value.value._variant === 'Ref')
        {
            return M.NamedAlternative({
                variantLabel: p.value.value.value.name.description!,
                alternative: p
            });
        }
        if (p._variant === 'Pattern' &&
            p.value._variant === 'SimplePattern' &&
            p.value.value._variant === 'lit')
        {
            const s = M.namelike(p.value.value.value);
            if (s !== void 0) return M.NamedAlternative({ variantLabel: s, alternative: p });
        }
        return M.NamedAlternative({
            variantLabel: '_anonymous' + nextAnonymousAlternativeNumber++,
            alternative: p
        });
    }

    function patternName([input, p]: readonly [Array<Input>, Pattern]) : M.NamedPattern {
        const n = findName(input) || findName(input[0]);
        if (n !== false) {
            if (p._variant !== 'SimplePattern') namedMustBeSimple(position(input[0]));
            return M.NamedPattern.named(M.NamedSimplePattern_({ name: n, pattern: p.value }));
        }
        return M.NamedPattern.anonymous(p);
    }

    // TODO: deal with situation where there's an or of ands, where
    // the branches of the and are named. The parsing is ambiguous, and
    // with the current code I think (?) you end up with the same name
    // attached to the or-branch as to the leftmost and-branch.

    return parseOp(pos,
                   body,
                   M.ORSYM,
                   p => [p, parseOp(pos,
                                    p,
                                    M.ANDSYM,
                                    p => [p, parsePattern(name, p)] as const,
                                    (p0, ps) => M.Alternative.and({
                                        pattern: patternName(p0),
                                        patterns: ps.map(patternName)
                                    }),
                                    p => M.Alternative.Pattern(p[1]))] as const,
                   (p0, ps) => M.Definition.or({
                       pattern: alternativeName(p0),
                       patterns: ps.map(alternativeName)
                   }),
                   p => M.Definition.Alternative(p[1]));
}

function parsePattern(name: symbol, body0: Array<Input>): Pattern {
    function parseSimple<A>(item0: Input, ks: (p: SimplePattern) => A, kf: () => A): A {
        const pos = position(item0);
        const item = peel(item0);
        function complain(): never { invalidPattern(stringify(name), item, pos); }
        if (typeof item === 'symbol') {
            const str = item.description!;
            switch (str) {
                case 'any': return ks(M.SimplePattern.any());
                case 'bool': return ks(M.SimplePattern.atom(M.AtomKind.Boolean()));
                case 'float': return ks(M.SimplePattern.atom(M.AtomKind.Float()));
                case 'double': return ks(M.SimplePattern.atom(M.AtomKind.Double()));
                case 'int': return ks(M.SimplePattern.atom(M.AtomKind.SignedInteger()));
                case 'string': return ks(M.SimplePattern.atom(M.AtomKind.String()));
                case 'bytes': return ks(M.SimplePattern.atom(M.AtomKind.ByteString()));
                case 'symbol': return ks(M.SimplePattern.atom(M.AtomKind.Symbol()));
                case 'embedded': return ks(M.SimplePattern.embedded());
                default: return ks((str[0] === '=')
                    ? M.SimplePattern.lit(Symbol.for(str.slice(1)))
                    : M.SimplePattern.Ref(parseRef(str, pos)));
            }
        } else if (Record.isRecord<Input, Tuple<Input>, M._embedded>(item)) {
            const label = item.label;
            if (Record.isRecord<Input, [], M._embedded>(label)) {
                if (label.length !== 0) complain();
                switch (label.label) {
                    case M.$lit:
                        if (item.length !== 1) complain();
                        return ks(M.SimplePattern.lit(item[0]));
                    default:
                        return kf();
                }
            } else {
                return kf();
            }
        } else if (isCompound(item)) {
            return kf();
        } else {
            return ks(M.SimplePattern.lit(strip(item)));
        }
    }

    function parseCompound(item0: Input): CompoundPattern {
        const pos = position(item0);
        const item = peel(item0);
        function complain(): never { invalidPattern(stringify(name), item, pos); }

        const walkSimple = (b: Input): SimplePattern => parseSimple(b, p => p, () => {
            throw new SchemaSyntaxError(`Compound patterns not accepted here`, position(b));
        });
        const walk = (b: Input): Pattern => parsePattern(name, [b]);

        function _maybeNamed<R,P>(
            named: (p: M.NamedSimplePattern_) => R,
            anonymous: (p: P) => R,
            recur: (b: Input) => P,
            literalName?: Input): (b: Input) => R
        {
            return (b: Input) => {
                let name = findName(b);
                if (name === false) {
                    if (literalName !== void 0 && typeof literalName === 'symbol') {
                        name = literalName;
                    }
                }
                if (name === false) {
                    return anonymous(recur(b));
                }
                return named(M.NamedSimplePattern_({ name, pattern: parseSimple(b, p => p, () =>
                    namedMustBeSimple(position(b))) }));
            };
        }
        const maybeNamed = _maybeNamed(M.NamedPattern.named, M.NamedPattern.anonymous, walk);
        const maybeNamedSimple =
            _maybeNamed(M.NamedSimplePattern.named, M.NamedSimplePattern.anonymous, walkSimple);

        function parseArrayLike(item: Array<Input>): CompoundPattern {
            if (is(item[item.length - 1], M.DOTDOTDOT)) {
                if (item.length < 2) complain();
                return M.CompoundPattern.tuple$STAR$({
                    fixed: item.slice(0, item.length - 2).map(maybeNamed),
                    variable: maybeNamedSimple(item[item.length - 2])
                });
            } else {
                return M.CompoundPattern.tuple(item.map(maybeNamed));
            }
        }

        if (Record.isRecord<Input, Tuple<Input>, M._embedded>(item)) {
            const label = item.label;
            if (Record.isRecord<Input, [], M._embedded>(label)) {
                if (label.length !== 0) complain();
                switch (label.label) {
                    case M.$rec:
                        if (item.length !== 2) complain();
                        return M.CompoundPattern.rec({
                            label: maybeNamed(item[0]),
                            fields: maybeNamed(item[1])
                        });
                    default:
                        complain();
                }
            } else {
                return M.CompoundPattern.rec({
                    label: M.NamedPattern.anonymous(M.Pattern.SimplePattern(M.SimplePattern.lit(label))),
                    fields: M.NamedPattern.anonymous(M.Pattern.CompoundPattern(parseArrayLike(item)))
                });
            }
        } else if (Array.isArray(item)) {
            return parseArrayLike(item);
        } else if (Dictionary.isDictionary<M._embedded, Input>(item)) {
            if (item.size === 2 && item.has(M.DOTDOTDOT)) {
                const v = item.clone();
                v.delete(M.DOTDOTDOT);
                const [[kp, vp]] = v.entries();
                return M.CompoundPattern.dictof({ key: walkSimple(kp), value: walkSimple(vp) });
            } else {
                return M.CompoundPattern.dict(
                    M.DictionaryEntries(item.mapEntries<M.NamedSimplePattern, Input, M._embedded>(
                        ([k, vp]) => [
                            strip(k),
                            _maybeNamed(
                                M.NamedSimplePattern.named,
                                M.NamedSimplePattern.anonymous,
                                walkSimple,
                                k)(vp)
                        ])));
            }
        } else if (Set.isSet<never>(item)) {
            if (item.size !== 1) complain();
            const [vp] = item.entries();
            return M.CompoundPattern.setof(walkSimple(vp));
        } else {
            complain();
        }
    }

    const body = peel(body0) as Array<Input>;
    if (body.length !== 1) {
        invalidPattern(stringify(name), body, body.length > 0 ? position(body[0]) : position(body));
    }
    return parseSimple(body[0],
                       M.Pattern.SimplePattern,
                       () => M.Pattern.CompoundPattern(parseCompound(body[0])));
}

function parseOp<Each, Combined>(pos: Position | null,
                                 body: Array<Input>,
                                 op: Input,
                                 each: (p: Array<Input>) => Each,
                                 combineN: (p0: Each, ps: Array<Each>) => Combined,
                                 finish1: (p: Each) => Combined): Combined
{
    const pieces = splitBy(body, op).map(each);
    if (pieces.length === 0) {
        throw new SchemaSyntaxError(
            preserves`Invalid Schema clause: cannot handle empty ${op}`, pos);
    }
    return (pieces.length === 1) ? finish1(pieces[0]) : combineN(pieces[0], pieces.slice(1));
}

function findName(x: Input): symbol | false {
    if (!Annotated.isAnnotated<never>(x)) return false;
    for (const a0 of x.annotations) {
        const a = peel(a0);
        if (typeof a === 'symbol') return a;
    }
    return false;
}

function parseRef(s: string, pos: Position | null): M.Ref {
    const pieces = s.split('.');
    return recordPosition(M.Ref({
        module: M.ModulePath(pieces.slice(0, pieces.length - 1).map(Symbol.for)),
        name: Symbol.for(pieces[pieces.length - 1])
    }), pos);
}