import Common

public struct ASTVisitorDriver {
  public init() {}

  public func visit<T>(
    expression: any AST.AnExpression, visitor: any ASTVisitor<T>, context: T
  ) -> Result<T> {
    return switch expression {
    case let e as AST.BinaryOperatorExpression:
      visitor.visit(node: e, driver: self, context: context)
    case let e as AST.Literal: visitor.visit(node: e, driver: self, context: context)
    default: .Error(Error(withMessage: "AST Expression Element Is Not Visitable"))
    }
  }

  public func visit<T>(
    state: any AST.AnState, visitor: any ASTVisitor<T>, context: T
  ) -> Result<T> {
    return switch state {
    case let s as AST.ParserStateDirectTransition:
      visitor.visit(node: s, driver: self, context: context)
    case let s as AST.ParserStateNoTransition:
      visitor.visit(node: s, driver: self, context: context)
    case let s as AST.ParserStateSelectTransition:
      visitor.visit(node: s, driver: self, context: context)
    default: .Error(Error(withMessage: "AST State Element (\(state)) Is Not Visitable"))
    }
  }

  public func visit<T>(
    statement: any AST.AnStatement, visitor: any ASTVisitor<T>, context: T
  ) -> Result<T> {
    return switch statement {
    case let s as AST.Parser: visitor.visit(node: s, driver: self, context: context)
    default: .Error(Error(withMessage: "AST Statement Element Is Not Visitable"))
    }
  }

  public func visit<T>(
    program: AST.Program, visitor: any ASTVisitor<T>, context: T
  ) -> Result<T> {

    var context = context
    for s in program.statements {
      switch visit(statement: s, visitor: visitor, context: context) {
      case .Ok(let c): context = c
      case .Error(let e): return .Error(e)
      }
    }

    return .Ok(context)
  }
}