import { getField } from './descriptionFileDeps'
import { getInnerRequest } from './getInnerRequest'
import { Resolver } from './typings'

export class SkavaComposerPlugin {
  source: string
  field: string
  target: string

  constructor(source: string, field: string, target: string) {
    this.source = source
    this.field = field
    this.target = target
  }

  apply(resolver: Resolver): void {
    const target = resolver.ensureHook(this.target)

    resolver
      .getHook(this.source)
      // AliasFieldPlugin
      .tapAsync('SkavaComposerPlugin', (request, resolveContext, callback) => {
        console.log('[composer] tapAsync')

        if (!request.descriptionFileData) return callback()
        const innerRequest = getInnerRequest(resolver, request)
        if (!innerRequest) return callback()

        const fieldData = getField(request.descriptionFileData, this.field)

        if (typeof fieldData !== 'object') {
          if (resolveContext.log)
            resolveContext.log(
              "Field '" +
                this.field +
                "' doesn't contain a valid alias configuration"
            )
          return callback()
        }

        const resolvedInnerRequest = innerRequest + ''
        const data1 = fieldData[resolvedInnerRequest]
        const data2 = fieldData[resolvedInnerRequest.replace(/^\.\//, '')]
        const data = typeof data1 !== 'undefined' ? data1 : data2

        if (data === innerRequest) return callback()
        if (data === undefined) return callback()
        if (data === false) {
          const ignoreObj = Object.assign({}, request, {
            path: false,
          })
          return callback(null, ignoreObj)
        }

        const obj = Object.assign({}, request, {
          path: request.descriptionFileRoot,
          request: data,
        })

        resolver.doResolve(
          target,
          obj,
          'aliased from description file ' +
            request.descriptionFilePath +
            " with mapping '" +
            innerRequest +
            "' to '" +
            data +
            "'",
          resolveContext,
          (err, result) => {
            console.log('[composer] doing resolve')

            if (err) return callback(err)

            // Don't allow other aliasing or raw request
            if (result === undefined) return callback(null, null)
            callback(null, result)
          }
        )
      })
  }
}