//  AbstractExpression（抽象表达式）：声明了抽象的解释操作，是所有终结符表达式以及非终结符表达式的父类
class AbstractExpression {
  constructor() {
    if (new.target === AbstractExpression) {
      throw new Error("抽象类不能被实例化");
    }
  }

  interpret() {
    if (this !== AbstractExpression) {
      throw new Error("抽象方法必须由子类重写实现");
    }
  }
}

// TerminalExpression (终结符表达式）
// 抽象表达式的子类，实现了与文法规则中的终结符相关联的解释操作
// 句子中的每一个终结符都是该类的一个实例，通常只有少数几个终结符表达式类

// 处理方向的解释器
class DirectionNode extends AbstractExpression {
  directMap = new Map([
    ['up', '向上'],
    ['down', '向下'],
    ['left', '向左'],
    ['right', '向右'],
  ]);

  // ctx: Context 用于存储解释器之外的一些全局信息，通常它临时存储需要解释的语句
  interpret(ctx) {
    return this.directMap.has(ctx) ? this.directMap.get(ctx) : "无效操作"
  }
}

// 处理动作的解释器
class ActionNode extends AbstractExpression {
  actionMap = new Map([
    ['move', '移动'],
    ['run', '奔跑'],
  ])

  interpret(ctx) {
    return this.actionMap.has(ctx) ? this.actionMap.get(ctx) : "无效操作"
  }
}

// 处理距离的解释器
class DistanceNode extends AbstractExpression {
  interpret(ctx) {
    return String(ctx);
  }
}

// NonterminalExpression（非终结符表达式）：也是抽象表达式的子类，实现了文法规则中非终结符的解释操作
// 由于非终结符表达式可以包含非终结符表达式以及终结符表达式，因此一般通过递归方式完成解释

// 处理语句的解释器，多个终结表达式组成一个非终结表达式，有点类似组合模式中 叶子对象和组合对象的关系
class SentenceNode extends AbstractExpression {
  direction = new DirectionNode();
  action = new ActionNode();
  distance = new DistanceNode();

  interpret(ctx) {
    const [ dir, a, dis ] = ctx.split(' ');
    // 将语句按照既定规则拆分给对应的“解释器”去“解释”
    return this.direction.interpret(dir) + this.action.interpret(a) + this.distance.interpret(dis);
  }
}

// 处理复合语句and的解释器
class AndNode extends AbstractExpression {

  /**
   * 解析器的实现思路
   * 1.把客户端传递来的表达式进行分解，分解成为一个一个的元素，并用一个对应的解析模型来封装这个元素的一些信息。
   * 2.根据每个元素的信息，转化成相对应的解析器对象。
   * 3.按照先后顺序，把这些解析器对象组合起来，就得到抽象语法树了。
   *
   * 为什么不把1和2合并,直接分解出一个元素就转换成相应的解析器对象？
   * 1.功能分离，不要让一个方法的功能过于复杂。
   * 2.为了今后的修改和扩展，现在语法简单，所以转换成解析器对象需要考虑的东西少，直接转换也不难，但要是语法复杂了，直接转换就很杂乱了。
   */
  interpret(ctx) {
    if (ctx.includes('and')) { // 如果有and这个标识，则将其分割为两个语句递归处理
      let idx = ctx.indexOf('and');
      let leftSentence = ctx.slice(0, idx - 1);
      let rightSentence = ctx.slice(idx + 4);
      // 左、右边的句子应该使用何种“解释器”来“解释”
      let leftExpr = leftSentence.includes('and') ? new AndNode() : new SentenceNode();
      let rightExpr = rightSentence.includes('and') ? new AndNode() : new SentenceNode();

      // 使用合适的“解释器”处理对应的句子（上下文），并按照既定规则进行合并“解释”
      return leftExpr.interpret(leftSentence) + "再" + rightExpr.interpret(rightSentence);
    }

    // 如果不是复合语句，只是普通语句 “方向 + 动作 + 距离”，直接让SentenceNode解释器来解释
    return new SentenceNode().interpret(ctx);
  }
}


var complex = new AndNode();
const val = complex.interpret("up move 5 and down run 10 and down move 10 and left run -9")
console.log(val); // 向上移动5再向下奔跑10再向下移动10再向左奔跑-9