import * as ts from 'typescript'

export interface CompilerInfo {
  compilerPath: string
  compilerVersion: string
  tsImpl: typeof ts
}
export interface OutputFile {
  text: string
  sourceMap: string
  declaration: ts.OutputFile
}

// const ModulesInRootPlugin: new (
//   a: string,
//   b: string,
//   c: string
// ) => ResolverPlugin = require('enhanced-resolve/lib/ModulesInRootPlugin')

const getInnerRequest: getInnerRequest = require('enhanced-resolve/lib/getInnerRequest')

type getInnerRequest = (resolver: Resolver, request: Request) => string

export interface AnyObj {
  [key: string]: any
}
export interface Request {
  __innerRequest?: string | Request
  __innerRequest_request?: Request
  __innerRequest_relativePath?: string
  request?: Request
  relativePath: string

  descriptionFileData: AnyObj | null
  descriptionFileRoot: string
  descriptionFilePath: string
}

export type Field = string[] | string

export interface NonStandardError extends Error {
  code?: number | undefined
}

export interface Callback {
  (err?: NonStandardError, result?: any): void

  log?: any
  stack?: any
  missing?: any
}

export type ResolverCallback = (request: Request, callback: Callback) => void

export interface ResolverPlugin {
  apply(resolver: Resolver): void
}

export interface ResolveContext {
  log(string: string, ...strings: string[]): void
}

export type AsyncTapCallback = (
  request: Request,
  resolveContext: ResolveContext,
  callback: Callback
) => void

export interface FileSystemReadCallback extends Function {
  (error: NonStandardError, content?: string | any): void
}
export interface FileSystem {
  readJson(descriptionFilePath: string, callback: FileSystemReadCallback): void
  readFile(descriptionFilePath: string, callback: FileSystemReadCallback): void
}

export interface Resolver {
  hooks: any
  apply(plugin: ResolverPlugin): void

  plugin(source: string, cb: ResolverCallback): void

  doResolve(
    target: Hook,
    req: Request,
    desc: string,
    resolveContext: ResolveContext,
    callback: Callback
  ): void

  ensureHook(name: string): Hook
  join(relativePath: string, innerRequest: Request): Request

  tapAsync(pluginName: string, callback: AsyncTapCallback): void
  getHook(source: string): Resolver

  fileSystem?: FileSystem

  // this is used in `join`? but where?
  toString(): string
}

export interface Hook {}

export interface Mapping {
  onlyModule: boolean
  alias: string
  aliasPattern: RegExp
  target: string
}

export interface PathPluginOptions {
  context?: string
}