/// SPDX-License-Identifier: GPL-3.0-or-later
/// SPDX-FileCopyrightText: Copyright © 2016-2023 Tony Garnock-Jones <tonyg@leastfixedpoint.com>

import {
    Token, Items,
    Pattern,
    foldItems, match, anonymousTemplate as template, commaJoin,

    scope, bind, seq, alt, upTo, atom, atomString, group,
    repeat, option, withoutSpace, map, mapm, rest, discard,
    value, succeed, fail, separatedOrTerminatedBy, not, TokenBase
} from '../syntax/index.js';
import * as Matcher from '../syntax/matcher.js';

//---------------------------------------------------------------------------
// AST types

export type Expr = Items;
export type Statement = Items;
export type Identifier = Token;
export type Type = Items;
export type Binder = { id: Identifier, type?: Type };

export interface TurnAction {
}

export interface FacetSetupAction extends TurnAction {
    body: Statement;
}

export interface SpawnStatement extends FacetSetupAction {
    name?: Expr;
    linkedToken: TokenBase | null;
    parentBinders: Binder[];
    parentInits: Expr[];
}

export interface FieldDeclarationStatement extends TurnAction {
    field: Binder;
    init?: Expr;
}

export interface AssertionEndpointStatement extends TurnAction {
    isDynamic: boolean,
    template: Expr,
    test?: Expr,
}

export interface StatementTurnAction extends TurnAction {
    body: Statement;
}

export interface GenericEventEndpointStatement extends StatementTurnAction {
    terminal: boolean;
    isDynamic: boolean;
}

export interface DataflowEndpointStatement extends GenericEventEndpointStatement {
    triggerType: 'dataflow';
    predicate: Expr;
}

export interface PseudoEventEndpointStatement extends GenericEventEndpointStatement {
    triggerType: 'stop';
}

export interface AssertionEventEndpointStatement extends GenericEventEndpointStatement {
    triggerType: 'asserted' | 'retracted' | 'message';
    pattern: ValuePattern;
}

export type EventHandlerEndpointStatement =
    DataflowEndpointStatement | PseudoEventEndpointStatement | AssertionEventEndpointStatement;

export interface TypeDefinitionStatement {
    expectedUse: 'message' | 'assertion';
    label: Identifier;
    fields: Binder[];
    wireName?: Expr;
}

export interface MessageSendStatement extends TurnAction {
    expr: Expr;
}

export interface DuringStatement extends FacetSetupAction {
    pattern: ValuePattern;
    test?: Expr,
}

export interface ReactStatement extends FacetSetupAction {
}

export interface AtStatement {
    target: Expr;
    body: Statement;
}

export interface CreateExpression {
    entity: Expr;
}

//---------------------------------------------------------------------------
// Value pattern AST types

export interface PCapture {
    type: 'PCapture',
    binder: Binder,
    inner: ValuePattern,
}

export interface PDiscard {
    type: 'PDiscard',
}

export interface PConstant {
    type: 'PConstant',
    value: Expr,
}

export interface PConstructor {
    type: 'PConstructor',
    ctor: Expr,
    arguments: ValuePattern[],
}

export interface PArray {
    type: 'PArray',
    elements: ValuePattern[],
}

export interface PDict {
    type: 'PDict',
    elements: [Expr, ValuePattern][],
}

export interface PUnquote {
    type: 'PUnquote',
    unquoted: ValuePattern,
}

export interface POuterUnquote {
    type: 'POuterUnquote',
    outer: Expr,
};

export interface PQuote {
    type: 'PQuote',
    quoted: ValuePattern,
}

export type ValuePattern =
    | PCapture | PDiscard
    | PConstant
    | PConstructor | PArray | PDict
    | PUnquote | POuterUnquote | PQuote
;

export interface StaticAnalysis {
    skeleton: Expr; // constructs a P.Pattern
    captureBinders: Binder[];
}

//---------------------------------------------------------------------------
// Parsers

function kw(text: string): Pattern<Token> {
    return value(o => seq(atom(':'), bind(o, 'value', atom(text, { skipSpace: false }))));
}

export class SyndicateParser {
    block(acc?: Items): Pattern<Items> {
        return group('{', map(rest, items => (acc?.push(... items), items)));
    }

    readonly statementBoundary = alt<any>(atom(';'), Matcher.newline);
    readonly exprBoundary = alt<any>(atom(';'), atom(','), group('{', discard), Matcher.end);

    readonly identifier: Pattern<Identifier> = atom();
    get binder(): Pattern<Binder> { return scope(o => bind(o, 'id', this.identifier)); }

    expr(... extraStops: Pattern<any>[]): Pattern<Expr> {
        return withoutSpace(upTo(alt(this.exprBoundary, ... extraStops)));
    }

    readonly type: (... extraStops: Pattern<any>[]) => Pattern<Type> = this.expr;

    statement(acc: Items): Pattern<any> {
        return alt<any>(this.block(acc),
                        withoutSpace(seq(map(upTo(this.statementBoundary),
                                             items => acc.push(... items)),
                                         map(this.statementBoundary,
                                             i => i ? acc.push(i) : void 0))));
    }

    turnAction<T extends TurnAction>(pattern: (scope: T) => Pattern<any>): Pattern<T> {
        return i => {
            const scope = Object.create(null);
            const p = pattern(scope);
            const r = p(i);
            if (r === null) return null;
            return [scope, r[1]];
        };
    }

    readonly headerExpr = this.expr(kw('asserting'), kw('let'));

    // Principal: Turn
    readonly spawn: Pattern<SpawnStatement> =
        this.turnAction(o => {
            o.linkedToken = null;
            o.parentBinders = [];
            o.parentInits = [];
            o.body = [];
            return seq(atom('spawn'),
                       option(map(atom('linked'), tok => o.linkedToken = tok)),
                       option(seq(atom('named'), bind(o, 'name', this.headerExpr))),
                       repeat(alt(
                           /* seq(kw('asserting'), map(this.headerExpr, e => o.initialAssertions.push(e))), */
                           map(scope(
                               (l: { b: Binder, init: Expr }) =>
                                   seq(kw('let'),
                                       bind(l, 'b', this.binder),
                                       atom('='),
                                       bind(l, 'init', this.headerExpr))),
                               l => {
                                   o.parentBinders.push(l.b);
                                   o.parentInits.push(l.init);
                               }))),
                       this.block(o.body));
        });

    // Principal: Turn
    readonly fieldDeclarationStatement: Pattern<FieldDeclarationStatement> =
        this.turnAction(o => {
            return seq(atom('field'),
                       bind(o, 'field', this.binder),
                       option(seq(atom('='), bind(o, 'init', this.expr()))),
                       this.statementBoundary);
        });

    // Principal: Turn
    readonly assertionEndpointStatement: Pattern<AssertionEndpointStatement> =
        this.turnAction(o => {
            o.isDynamic = true;
            return seq(atom('assert'),
                       option(map(kw('snapshot'), _ => o.isDynamic = false)),
                       bind(o, 'template', this.expr(seq(atom('when'), group('(', discard)))),
                       option(seq(atom('when'), group('(', bind(o, 'test', this.expr())))),
                       this.statementBoundary);
        });

    blockTurnAction(kw: Pattern<any>): Pattern<StatementTurnAction> {
        return this.turnAction(o => {
            o.body = [];
            return seq(kw, this.block(o.body));
        });
    }

    // Principal: Turn
    readonly dataflowStatement = this.blockTurnAction(atom('dataflow'));

    mandatoryIfNotTerminal(o: GenericEventEndpointStatement, p: Pattern<any>): Pattern<any> {
        return i => {
            return (o.terminal) ? option(p)(i) : p(i);
        };
    }

    // Principal: Turn
    readonly eventHandlerEndpointStatement: Pattern<EventHandlerEndpointStatement> =
        this.turnAction(o => {
            o.terminal = false;
            o.isDynamic = true;
            o.body = [];
            return seq(option(map(atom('stop'), _ => o.terminal = true)),
                       atom('on'),
                       alt<any>(seq(map(group('(', bind(o as DataflowEndpointStatement, 'predicate',
                                                        this.expr())),
                                        _ => o.triggerType = 'dataflow'),
                                    this.mandatoryIfNotTerminal(o, this.statement(o.body))),
                                mapm(seq(bind(o, 'triggerType', atomString('stop')),
                                         option(this.statement(o.body))),
                                     v => o.terminal ? fail : succeed(v)),
                                seq(bind(o, 'triggerType',
                                         alt(atomString('asserted'),
                                             atomString('retracted'),
                                             atomString('message'))),
                                    option(map(kw('snapshot'), _ => o.isDynamic = false)),
                                    bind(o as AssertionEventEndpointStatement, 'pattern',
                                         this.valuePattern(1, atom('=>'))),
                                    this.mandatoryIfNotTerminal(
                                        o, seq(atom('=>'), this.statement(o.body))))));
        });

    // Principal: none
    readonly typeDefinitionStatement: Pattern<TypeDefinitionStatement> =
        scope(o => seq(bind(o, 'expectedUse', alt(atomString('message'), atomString('assertion'))),
                       atom('type'),
                       bind(o, 'label', this.identifier),
                       group('(', bind(o, 'fields', repeat(this.binder, { separator: atom(',') }))),
                       option(seq(atom('='),
                                  bind(o, 'wireName', withoutSpace(upTo(this.statementBoundary))))),
                       this.statementBoundary));

    // Principal: Turn
    readonly messageSendStatement: Pattern<MessageSendStatement> =
        this.turnAction(o => seq(atom('send'),
                                  atom('message'),
                                  not(this.statementBoundary),
                                  bind(o, 'expr', withoutSpace(upTo(this.statementBoundary))),
                                  this.statementBoundary));

    // Principal: Turn
    readonly duringStatement: Pattern<DuringStatement> =
        this.turnAction(o => {
            o.body = [];
            return seq(atom('during'),
                       bind(o, 'pattern',
                            this.valuePattern(1, atom('=>'), seq(atom('when'), group('(', discard)))),
                       option(seq(atom('when'), group('(', bind(o, 'test', this.expr())))),
                       seq(atom('=>'), this.statement(o.body)));
        });

    // Principal: Turn
    readonly reactStatement: Pattern<ReactStatement> =
        this.turnAction(o => {
            o.body = [];
            return seq(atom('react'), this.block(o.body));
        });

    // Principal: Turn
    readonly stopStatement = this.blockTurnAction(atom('stop'));

    // Principal: none
    readonly atStatement: Pattern<AtStatement> =
        scope(o => {
            o.body = [];
            return seq(atom('at'),
                       bind(o, 'target', this.expr()),
                       this.block(o.body));
        });

    // Principal: none
    readonly createExpression: Pattern<CreateExpression> =
        scope(o => seq(atom('create'), bind(o, 'entity', this.expr())));

    //---------------------------------------------------------------------------
    // Syntax of patterns over Value, used in endpoints

    // $id - capture of discard
    // _ - discard
    //
    // expr(pat, ...) - record ctor
    // $id(pat) - nested capture
    // [pat, ...] - array pat
    // {expr: pat, ...} - dict pat
    //
    // expr(expr, ...) - constant
    // [expr, ...] - constant
    // {expr: expr, ...} - constant
    // other - constant

    readonly pCaptureBinder: Pattern<Binder> =
        mapm(this.binder, i => {
            return i.id.text.startsWith('$')
                ? succeed({ id: { ... i.id, text: i.id.text.slice(1) }, type: i.type })
                : fail;
        });

    readonly pDiscard: Pattern<void> =
        mapm(this.identifier, i => i.text === '_' ? succeed(void 0) : fail);

    pUnquote(level: number, extraStops: Pattern<any>[]): Pattern<PUnquote | POuterUnquote> {
        if (level == 1) {
            return scope<POuterUnquote>(o => {
                o.type = 'POuterUnquote';
                return seq(atom('\\'), bind(o, 'outer', this.expr(... extraStops)));
            });
        } else {
            return scope<PUnquote>(o => {
                o.type = 'PUnquote';
                return seq(atom('\\'), bind(o, 'unquoted', this.valuePattern(level - 1, ... extraStops)));
            });
        }
    }

    pQuote(level: number, extraStops: Pattern<any>[]): Pattern<PQuote> {
        return scope(o => {
            o.type = 'PQuote';
            return seq(kw('pattern'), bind(o, 'quoted', this.valuePattern(level + 1, ... extraStops)));
        });
    }

    hasCapturesOrDiscards(e: Expr): boolean {
        return foldItems(e,
                         t => match(alt<any>(this.pCaptureBinder, this.pDiscard), [t], null) !== null,
                         (_g, b, _k) => b,
                         bs => bs.some(b => b));
    }

    pArray(level: number): Pattern<PArray> {
        return scope(o => {
            o.type = 'PArray';
            return group(
                '[', mapm(bind(o, 'elements',
                               separatedOrTerminatedBy(this.valuePattern(level), atom(','))),
                          v => (o.elements.every(p => p.type === 'PConstant') ? fail : succeed(v))));
        });
    }

    pDict(level: number): Pattern<PDict> {
        return scope(o => {
            o.type = 'PDict';
            return group(
                '{', mapm(bind(o,
                               'elements',
                               separatedOrTerminatedBy(
                                   value<[Expr, ValuePattern]>(e => {
                                       e.value = [] as any;
                                       return seq(
                                           bind(e.value, '0', this.expr(atom(':'))),
                                           atom(':'),
                                           bind(e.value, '1', this.valuePattern(level)));
                                   }),
                                   atom(','))),
                          v => (o.elements.every(e => e[1].type === 'PConstant') ? fail : succeed(v))));
        });
    }

    pConstructor(level: number, extraStops: Pattern<any>[]): Pattern<PConstructor> {
        return scope(o => {
            o.type = 'PConstructor';
            return seq(bind(o, 'ctor', this.expr(... extraStops, group('(', discard))),
                       // map(anything({ advance: false }), g => o.argumentGroup = g),
                       group('(', bind(o, 'arguments',
                                       separatedOrTerminatedBy(
                                           this.valuePattern(level, ... extraStops),
                                           atom(',')))));
        });
    }

    valuePattern(level: number, ... extraStops: Pattern<any>[]): Pattern<ValuePattern> {
        return withoutSpace(alt<ValuePattern>(
            scope<PCapture>(o => {
                o.type = 'PCapture';
                o.inner = { type: 'PDiscard' };
                return bind(o, 'binder', this.pCaptureBinder);
            }),
            scope(o => map(this.pDiscard, _ => o.type = 'PDiscard')),
            this.pArray(level),
            this.pDict(level),
            this.pQuote(level, extraStops),
            this.pUnquote(level, extraStops),
            mapm<PConstructor, PConstant | PCapture | PConstructor>(
                this.pConstructor(level, extraStops),
                o => {
                    // if (o.arguments.every(a => a.type === 'PConstant')) {
                    //     return succeed({
                    //         type: 'PConstant',
                    //         value: [... o.ctor, o.argumentGroup],
                    //     });
                    // } else
                    if (this.hasCapturesOrDiscards(o.ctor)) {
                        const r = match(this.pCaptureBinder, o.ctor, null);
                        if (r !== null && o.arguments.length === 1) {
                            return succeed({
                                type: 'PCapture',
                                inner: o.arguments[0],
                                binder: r
                            });
                        } else {
                            return fail;
                        }
                    } else {
                        return succeed(o);
                    }
                }),
            map(this.expr(... extraStops), e => ({ type: 'PConstant', value: e }))
        ));
    }
}

export class SyndicateTypedParser extends SyndicateParser {
    get binder(): Pattern<Binder> {
        return scope(o => seq(bind(o, 'id', this.identifier),
                              option(seq(atom(':'),
                                         bind(o, 'type', this.type(atom('=')))))));
    }
}

//---------------------------------------------------------------------------
// Value pattern utilities

export function compilePattern(pattern: ValuePattern): StaticAnalysis {
    const captureBinders: Binder[] = [];

    function walk(pattern: ValuePattern): Expr {
        switch (pattern.type) {
            case 'PDiscard':
                return template`(__SYNDICATE__.QuasiValue._)`;
            case 'PCapture': {
                captureBinders.push(pattern.binder);
                return template`(__SYNDICATE__.QuasiValue.bind(${walk(pattern.inner)}))`;
            }
            case 'PConstant':
                return template`(__SYNDICATE__.QuasiValue.lit(__SYNDICATE__.fromJS(${pattern.value})))`;
            case 'PConstructor': {
                const pieces = [template`${pattern.ctor}`, ... pattern.arguments.map(walk)];
                return template`(__SYNDICATE__.QuasiValue.ctor(${commaJoin(pieces)}))`;
            }
            case 'PArray': {
                const pieces = pattern.elements.map(walk);
                return template`(__SYNDICATE__.QuasiValue.arr(${commaJoin(pieces)}))`;
            }
            case 'PDict': {
                const pieces = pattern.elements.map(([k, v]) => template`[${k}, ${walk(v)}]`);
                return template`(__SYNDICATE__.QuasiValue.dict(${commaJoin(pieces)}))`;
            }
            case 'PQuote':
                return template`(__SYNDICATE__.QuasiValue.quote(${walk(pattern.quoted)}))`;
            case 'PUnquote':
                return template`(__SYNDICATE__.QuasiValue.unquote(${walk(pattern.unquoted)}))`;
            case 'POuterUnquote':
                return template`(__SYNDICATE__.QuasiValue.unquote(${pattern.outer}))`;
        }
    }

    const skeleton = walk(pattern);

    return {
        skeleton,
        captureBinders,
    };
}