import TreeRegexp from './TreeRegexp'
import ParameterType from './ParameterType'
import Group from './Group'
import { CucumberExpressionError } from './Errors'

export default class Argument<T> {
  public static build(
    treeRegexp: TreeRegexp,
    text: string,
    parameterTypes: Array<ParameterType<any>>
  ): Array<Argument<any>> {
    const group = treeRegexp.match(text)
    if (!group) {
      return null
    }

    const argGroups = group.children

    if (argGroups.length !== parameterTypes.length) {
      throw new CucumberExpressionError(
        `Expression ${treeRegexp.regexp} has ${
          argGroups.length
        } capture groups (${argGroups.map(g => g.value)}), but there were ${
          parameterTypes.length
        } parameter types (${parameterTypes.map(p => p.name)})`
      )
    }

    return parameterTypes.map(
      (parameterType, i) => new Argument(argGroups[i], parameterType)
    )
  }

  constructor(
    public readonly group: Group,
    public readonly parameterType: ParameterType<T>
  ) {
    this.group = group
    this.parameterType = parameterType
  }

  /**
   * Get the value returned by the parameter type's transformer function.
   *
   * @param thisObj the object in which the transformer function is applied.
   */
  public getValue(thisObj: any): T {
    const groupValues = this.group ? this.group.values : null
    return this.parameterType.transform(thisObj, groupValues)
  }
}

module.exports = Argument