import { JsonQLExpr } from "@mwater/jsonql"
import {
  ExtensionExpr,
  Schema,
  Variable,
  Expr,
  AggrStatus,
  EnumValue,
  LiteralType,
  FieldExpr,
  PromiseExprEvaluatorContext
} from "../src"
import { CleanExprOptions } from "../src/ExprCleaner"
import { ValidateOptions } from "../src/ExprValidator"
import { ExprExtension, registerExprExtension } from "../src/extensions"

/** Sets up a test extension */
export function setupTestExtension() {
  registerExprExtension("test", testExtension)
}

/** Extension to the expression language. Referenced by ExtentionExprs  */
const testExtension: ExprExtension<ExtensionExpr> = {
  cleanExpr(expr: ExtensionExpr, options: CleanExprOptions, schema: Schema): Expr {
    return expr
  },

  getExprAggrStatus(expr: ExtensionExpr, schema: Schema) {
    return "individual"
  },

  validateExpr(expr: ExtensionExpr, options: ValidateOptions, schema: Schema) {
    return "test"
  },

  /** Return array of { id: <enum value>, name: <localized label of enum value> } */
  getExprEnumValues(expr: ExtensionExpr, schema: Schema) {
    return null
  },

  /** Gets the id table of an expression of type id */
  getExprIdTable(expr: Expr, schema: Schema) {
    return "t1"
  },

  /** Gets the type of an expression */
  getExprType(expr: Expr, schema: Schema) {
    return "number"
  },

  /** Summarizes expression as text */
  summarizeExpr(expr: Expr, locale: string | undefined, schema: Schema) {
    return "test"
  },

  /** Get a list of fields that are referenced in a an expression
   * Useful to know which fields and joins are used. Includes joins as fields
   */
  getReferencedFields(expr: Expr, schema: Schema) {
    return []
  },

  /** Compile to JsonQL */
  compileExpr(
    expr: Expr,
    tableAlias: string,
    schema: Schema,
  ): JsonQLExpr {
    return { type: "literal", value: 4 }
  },

  /** Evaluate an expression given the context */
  evaluate(
    expr: Expr,
    context: PromiseExprEvaluatorContext,
    schema: Schema | undefined,
    locale: string | undefined,
  ): Promise<any> {
    return Promise.resolve(4)
  },

  /** Evaluate an expression synchronously */
  evaluateSync(
    expr: Expr,
    schema: Schema | undefined,
    locale: string | undefined,
  ): any {
    return 4
  }
}