// sum isminde bir Lambda tanımlıyoruz
const sum = (a, b) => a + b;
console.log(typeof sum);    // "function"

// İlk tanımımız ExpressionType, hatırlarsınız C# için 80+ adet vardı, desteklediğimiz tüm Expression türleri aşağıdakiler:
export const enum ExpressionType {
    Literal = 'Literal',    // 42, "Marvin"
    Variable = 'Variable',  // a + 42, buradaki "a" bir değişken
    Unary = 'Unary',        // -42, buradaki "-" bir Unary işlem
    Group = 'Group',        // (a, b), direk kullanımı yasak olsa da Lambda için destek vermemiz gerekiyor
    Assign = 'Assign',      // a: 42, direk kullanımı yasak olsa da obje oluştururken destek vermemiz gerekiyor
    Object = 'Object',      // { a: 42 }
    Array = 'Array',        // [42]
    Member = 'Member',      // a.b, buradaki "b" bir Member, a ise Variable
    Indexer = 'Indexer',    // a[4]
    Func = 'Func',          // (a, b) => a + b
    Call = 'Call',          // func(1, 2)
    Ternary = 'Ternary',    // a ? 1 : 0
    Binary = 'Binary'       // a + b, a < b
}

// Sadece Expression tipini tutan bir yapı
export interface Expression {
    readonly type: ExpressionType;
}

// Tüm Expression'ları listelemeyeceğim. Bir kaç örnek görmemiz yeterli olacaktır
export interface LiteralExpression extends Expression {
    readonly value    // tipi "any", yani her türlü veri atanabilir
}

export interface VariableExpression extends Expression {
    readonly name: string;
}

export interface UnaryExpression extends Expression {
    readonly operator: string;      // yukarıdaki örnek için "-"
    readonly target: Expression;    // yukarıdaki örnek için LiteralExpression ancak her tür Expression olabilir
}

// son örnek için en güzel tercih
export interface BinaryExpression extends Expression {
    readonly operator: string;      // yaptığımız işlem, +, -, <, > gibi.
    readonly left: Expression;      // işleme dahil olan sol Expression
    readonly right: Expression;     // işleme dahil olan sağ Expression, yine her tür Expression olabilir
}
...

export function tokenize<T extends Expression = Expression>(exp: string): T

const lambda = tokenize<FuncExpression>('(a, b) => a < b');

const lambda = (a, b) => a < b;
console.log(lambda.toString());     // "(a, b) => a < b"

const func = function (a, b) { return a < b; }
console.log(func.toString())        // "function (a, b) { return a < b; }"

// parse etmek istediğimiz ifade
str = "function (a, b) { return a + b };"

// praser "function" ifadesi ile karşılaşınca fonksiyon parse etme moduna girer
// to('{') çağrısı ile "function" ifadesinden sonra parantez arar, bulamaz ise hata fırlatır

function getExp(): Expression {
    skip();     // boşlukları atla

    // sırayla tek başına kullanılabilen Expression'ları dene
    let e: Expression = tryLiteral()
        || tryVariable()
        || tryUnary()
        || tryGroup()
        || tryObject()
        || tryArray();

    // eğer bir Expression bulamazsan dön
    if (!e) return e;
    // Expression bilinen (true, false, null gibi) bir değer mi?
    e = tryKnown(e) || e;

    let r: Expression;
    do {
        // boşlukları atla
        skip();

        r = e;
        // birleşik kullanılan Expression'ları dene
        e = tryMember(e)
            || tryIndexer(e)
            || tryFunc(e)
            || tryCall(e)
            || tryTernary(e)
            || tryBinary(e);
    } while (e)

    return r;
}

function tryObject() {
    // "{" ile başlaması gerekiyor, yoksa başarısız
    if (!get('{')) return null;

    // Obje içinde yapılan tüm atamaları burada saklayacğız
    const es: AssignExpression[] = [];
    do {
        skip();
        // sıradaki Expression'ı oku
        const ve = getExp() as VariableExpression;
        // eğer bir değişken ya da üye erişimi değil ise hata fırlat
        // { a: 42, b.c } desteklediğimiz yapı
        if (ve.type !== ExpressionType.Variable && ve.type !== ExpressionType.Member)
            throw new Error(`Invalid assignment at ${idx}`);

        skip();
        // atama karakteri var ise
        if (get(':')) {
            // artık değişken olmak zorunda
            // { b.c: 42 } geçersiz bir ifade
            if (ve.type !== ExpressionType.Variable)
                throw new Error(`Invalid assignment at ${idx}`);

            skip();

            es.push(assignExp(ve.name, getExp()));
        }
        else {
            es.push(assignExp(ve.name, ve));
        }
    // her atama arasında "," olmalı, eğer yok ise işlem tamamlandı demektir
    } while (get(','));

    // son karakterimiz "}" bulunamaz ise hata fırlatılır
    to('}');

    // objemiz hazır
    return objectExp(es);
}

protected visit(exp: Expression, scopes: any[]) {
    switch (exp.type) {
        // desteklenen her Expression'ı ziyaret ediyoruz
        case ExpressionType.Array: return this.visitArray(<any>exp, scopes);
        case ExpressionType.Binary: return this.visitBinary(<any>exp, scopes);
        case ExpressionType.Call: return this.visitCall(<any>exp, scopes);
        case ExpressionType.Indexer: return this.visitIndexer(<any>exp, scopes);
        case ExpressionType.Literal: return this.visitLiteral(<any>exp, scopes);
        case ExpressionType.Member: return this.visitMember(<any>exp, scopes);
        case ExpressionType.Object: return this.visitObject(<any>exp, scopes);
        case ExpressionType.Ternary: return this.visitTernary(<any>exp, scopes);
        case ExpressionType.Unary: return this.visitUnary(<any>exp, scopes);
        case ExpressionType.Variable: return this.visitVariable(<any>exp, scopes);
        case ExpressionType.Group:
            const gexp = exp as GroupExpression;
            if (gexp.expressions.length == 1)
                return this.visit(gexp.expressions[0], scopes);
        // kendi başına Assign kullanımı desteklenmiyor. sadece Object Expression içinde olabilir
        case ExpressionType.Assign:
        // kendi başına Func kullanımı desteklenmiyor, sadece Call için parametre olabilir
        case ExpressionType.Func:
            throw new Error(`Invalid ${exp.type} expression usage`);
        default: throw new Error(`Unsupported ExpressionType ${exp.type}`);
    }
}

// örnek olarak Call expression'a bakalım
protected visitCall(exp: CallExpression, scopes: any[]) {
    // fonksiyonu temsil eden Expression'ı ziyaret ediyor ve değerini buluyoruz
    const func = this.visit(exp.callee, scopes);
    // argümanları ziyaret ediyor ve değerlerini buluyoruz
    // Func kullanımına sadece Call içinde izin veriyoruz
    // örnek: items.sum(i => i)     -> buradaki i => i bir Func ve sadece Call içinde parametre olabilir
    const args = exp.args.map(a => a.type === ExpressionType.Func ? this.visitFunc(<any>a, scopes) : this.visit(a, scopes));
    // foknsiyonumuzu çağırıyoruz
    return func(...args);
}
...

export function evaluate(exp: Expression | string, ...scopes: any[]) {
    return new ExpressionVisitor().process(typeof exp === 'string' ? tokenize(exp) : exp, scopes);
}

// değerlendirilmesini istediğimiz karşılaştırma ifademiz
// ikinci parametrede verdiğimiz obje "v1" ve "v2" değişkenlerini aramak için kullanılacak
const value = evaluate('v1 >= v2', { v1: 5, v2: 3 });
console.log(value);     // true

// fonksiyon parse ediyoruz, fonksiyon gerekli parametreleri aldığı için scope ihtiyacı duymuyoruz
const func = evaluate('function(a, b) { return a < b; }');
console.log(func(5, 3));    // false

// istersek fonksiyon yerine lambda yazımını da kullanabiliriz
const lambda = evaluate(tokenize('(a, b) => a < b'));
console.log(func(5, 3));    // false