//
// Copyright 2024 CloudWeGo Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

package expr

import (
    `fmt`
)

// Type is tyep expression type.
type Type int

const (
    // CONST indicates that the expression is a constant.
    CONST Type = iota

    // TERM indicates that the expression is a Term reference.
    TERM

    // EXPR indicates that the expression is a unary or binary expression.
    EXPR
)

var typeNames = map[Type]string {
    EXPR  : "Expr",
    TERM  : "Term",
    CONST : "Const",
}

// String returns the string representation of a Type.
func (self Type) String() string {
    if v, ok := typeNames[self]; ok {
        return v
    } else {
        return fmt.Sprintf("expr.Type(%d)", self)
    }
}

// Operator represents an operation to perform when Type is EXPR.
type Operator uint8

const (
    // ADD performs "Add Expr.Left and Expr.Right".
    ADD Operator = iota

    // SUB performs "Subtract Expr.Left by Expr.Right".
    SUB

    // MUL performs "Multiply Expr.Left by Expr.Right".
    MUL

    // DIV performs "Divide Expr.Left by Expr.Right".
    DIV

    // MOD performs "Modulo Expr.Left by Expr.Right".
    MOD

    // AND performs "Bitwise AND Expr.Left and Expr.Right".
    AND

    // OR performs "Bitwise OR Expr.Left and Expr.Right".
    OR

    // XOR performs "Bitwise XOR Expr.Left and Expr.Right".
    XOR

    // SHL performs "Bitwise Shift Expr.Left to the Left by Expr.Right Bits".
    SHL

    // SHR performs "Bitwise Shift Expr.Left to the Right by Expr.Right Bits".
    SHR

    // POW performs "Raise Expr.Left to the power of Expr.Right"
    POW

    // NOT performs "Bitwise Invert Expr.Left".
    NOT

    // NEG performs "Negate Expr.Left".
    NEG
)

var operatorNames = map[Operator]string {
    ADD : "Add",
    SUB : "Subtract",
    MUL : "Multiply",
    DIV : "Divide",
    MOD : "Modulo",
    AND : "And",
    OR  : "Or",
    XOR : "ExclusiveOr",
    SHL : "ShiftLeft",
    SHR : "ShiftRight",
    POW : "Power",
    NOT : "Invert",
    NEG : "Negate",
}

// String returns the string representation of a Type.
func (self Operator) String() string {
    if v, ok := operatorNames[self]; ok {
        return v
    } else {
        return fmt.Sprintf("expr.Operator(%d)", self)
    }
}

// Expr represents an expression node.
type Expr struct {
    Type  Type
    Term  Term
    Op    Operator
    Left  *Expr
    Right *Expr
    Const int64
}

// Ref creates an expression from a Term.
func Ref(t Term) (p *Expr) {
    p = newExpression()
    p.Term = t
    p.Type = TERM
    return
}

// Int creates an expression from an integer.
func Int(v int64) (p *Expr) {
    p = newExpression()
    p.Type = CONST
    p.Const = v
    return
}

func (self *Expr) clear() {
    if self.Term != nil  { self.Term.Free() }
    if self.Left != nil  { self.Left.Free() }
    if self.Right != nil { self.Right.Free() }
}

// Free returns the Expr into pool.
// Any operation performed after Free is undefined behavior.
func (self *Expr) Free() {
    self.clear()
    freeExpression(self)
}

// Evaluate evaluates the expression into an integer.
// It also implements the Term interface.
func (self *Expr) Evaluate() (int64, error) {
    switch self.Type {
        case EXPR  : return self.eval()
        case TERM  : return self.Term.Evaluate()
        case CONST : return self.Const, nil
        default    : panic("invalid expression type: " + self.Type.String())
    }
}

/** Expression Combinator **/

func combine(a *Expr, op Operator, b *Expr) (r *Expr) {
    r = newExpression()
    r.Op = op
    r.Type = EXPR
    r.Left = a
    r.Right = b
    return
}

func (self *Expr) Add(v *Expr) *Expr { return combine(self, ADD, v) }
func (self *Expr) Sub(v *Expr) *Expr { return combine(self, SUB, v) }
func (self *Expr) Mul(v *Expr) *Expr { return combine(self, MUL, v) }
func (self *Expr) Div(v *Expr) *Expr { return combine(self, DIV, v) }
func (self *Expr) Mod(v *Expr) *Expr { return combine(self, MOD, v) }
func (self *Expr) And(v *Expr) *Expr { return combine(self, AND, v) }
func (self *Expr) Or (v *Expr) *Expr { return combine(self, OR , v) }
func (self *Expr) Xor(v *Expr) *Expr { return combine(self, XOR, v) }
func (self *Expr) Shl(v *Expr) *Expr { return combine(self, SHL, v) }
func (self *Expr) Shr(v *Expr) *Expr { return combine(self, SHR, v) }
func (self *Expr) Pow(v *Expr) *Expr { return combine(self, POW, v) }
func (self *Expr) Not()        *Expr { return combine(self, NOT, nil) }
func (self *Expr) Neg()        *Expr { return combine(self, NEG, nil) }

/** Expression Evaluator **/

var binaryEvaluators = [256]func(int64, int64) (int64, error) {
    ADD: func(a, b int64) (int64, error) { return a + b, nil },
    SUB: func(a, b int64) (int64, error) { return a - b, nil },
    MUL: func(a, b int64) (int64, error) { return a * b, nil },
    DIV: idiv,
    MOD: imod,
    AND: func(a, b int64) (int64, error) { return a & b, nil },
     OR: func(a, b int64) (int64, error) { return a | b, nil },
    XOR: func(a, b int64) (int64, error) { return a ^ b, nil },
    SHL: func(a, b int64) (int64, error) { return a << b, nil },
    SHR: func(a, b int64) (int64, error) { return a >> b, nil },
    POW: ipow,
}

func (self *Expr) eval() (int64, error) {
    var lhs int64
    var rhs int64
    var err error
    var vfn func(int64, int64) (int64, error)

    /* evaluate LHS */
    if lhs, err = self.Left.Evaluate(); err != nil {
        return 0, err
    }

    /* check for unary operators */
    switch self.Op {
        case NOT: return self.unaryNot(lhs)
        case NEG: return self.unaryNeg(lhs)
    }

    /* check for operators */
    if vfn = binaryEvaluators[self.Op]; vfn == nil {
        panic("invalid operator: " + self.Op.String())
    }

    /* must be a binary expression */
    if self.Right == nil {
        panic("operator " + self.Op.String() + " is a binary operator")
    }

    /* evaluate RHS, and call the operator */
    if rhs, err = self.Right.Evaluate(); err != nil {
        return 0, err
    } else {
        return vfn(lhs, rhs)
    }
}

func (self *Expr) unaryNot(v int64) (int64, error) {
    if self.Right == nil {
        return ^v, nil
    } else {
        panic("operator Invert is an unary operator")
    }
}

func (self *Expr) unaryNeg(v int64) (int64, error) {
    if self.Right == nil {
        return -v, nil
    } else {
        panic("operator Negate is an unary operator")
    }
}