import { Terminal, Identifier } from './terminal'
import { ILGen } from '../SDT/ILGen'
import { LexicalScope } from '../SDT/LexicalScope'

export class Expr {
  protected _rval: string
  constructor(private op: string, protected left: (Expr | Terminal | Args), protected right: (Expr | Terminal | Args)) { }

  public print(level: number = 0): void {
    const pad: string = ''.padStart(level * 2)
    console.log(pad + this.op)
    this.left && this.left.print(level + 1)
    this.right && this.right.print(level + 1)
  }

  //代码生成
  public gen(il: ILGen, scope: LexicalScope) {
    if (this.left && (<Expr | Args>this.left).gen) {
      (<Expr | Args>this.left).gen(il, scope)
    }
    if (this.right && (<Expr | Args>this.right).gen) {
      (<Expr | Args>this.right).gen(il, scope)
    }
    const tempVar: string = scope.bindTempVar()
    il.add(`set ${tempVar} ${(<Expr | Terminal>this.left).rvalue()} ${this.op} ${(<Expr | Terminal>this.right).rvalue()}`)
    this._rval = tempVar;
  }

  //获取临时标识符名
  public rvalue(): string {
    return this._rval;
  }

  //绑定词法作用域
  public bindLexicalScope(scope) {
    if (this.left && (<Expr | Args>this.left).bindLexicalScope) {
      (<Expr | Args>this.left).bindLexicalScope(scope)
    }
    if (this.right && (<Expr | Args>this.right).bindLexicalScope) {
      (<Expr | Args>this.right).bindLexicalScope(scope)
    }
  }
}

//函数调用表达式
export class FunctionCallExpr extends Expr {
  constructor(private id: Identifier, private args: Args) {
    super('call', id, args)
  }

  gen(il: ILGen, scope: LexicalScope) {
    (<Expr | Args>this.right).gen(il, scope)
    const tempVar = scope.bindTempVar()
    il.add(`call ${scope.getLexemeName((<Terminal>this.left).lvalue())}`)
    this._rval = tempVar
  }
}

export class AssignExpr extends Expr {
  constructor(private id: Identifier, private expr: Expr | Terminal) {
    super('=', id, expr)
  }

  gen(il: ILGen, scope: LexicalScope): void {
    il.add(`declare ${scope.getLexemeName(this.id.lvalue())}`);
    (<Expr>this.expr).gen(il, scope)
    il.add(`${scope.getLexemeName(this.id.lvalue())}=${this.expr.rvalue()}`)
  }
}

export class Args {
  constructor(private args: Array<Expr | Identifier>, private type = 'call') { }

  print(level): void {
    this.args.forEach(x => {
      x.print(level)
    })
  }

  size(): number {
    return this.args.length
  }

  bindLexicalScope(scope: LexicalScope): void {
    for (let i = 0; i < this.args.length; i++) {
      if (this.type === 'function') {
        scope.bind((<Identifier>this.args[i]).value)
        this.args[i].bindLexicalScope(scope)
      } else {
        this.args[i].bindLexicalScope && this.args[i].bindLexicalScope(scope)
      }
    }
  }

  gen(il: ILGen, scope: LexicalScope): void {
    if (this.type == 'call') {
      for (let i = 0; i < this.args.length; i++) {
        const expr = this.args[i]
        if ((<Expr>expr).gen) {
          (<Expr>expr).gen(il, scope)
        }
        il.add(`pass ${expr.rvalue()}`)
      }
    }
  }

}