'use strict'

import Modem = require('docker-modem')
import { Image } from './image'
import fs = require('fs')

/**
 * Class representing container execution
 */

export class Exec {
  modem: Modem
  container: Container
  id: string
  data: Object = {}

  /**
   * Create an execution
   * @param  {Modem}      modem     Modem to connect to the remote service
   * @param  {Container}  container Container that owns the execution (optional)
   * @param  {string}     id        Id of the execution
   */

  constructor (modem: Modem, container: Container, id: string) {
    this.modem = modem
    this.container = container
    this.id = id
  }

  /**
   * Create an exec instance in a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/create-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise return the new exec instance
   */
  create (opts?: Object): Promise<Exec> {
    const call = {
      path: `/containers/${this.container.id}/exec?`,
      method: 'POST',
      options: opts,
      statusCodes: {
        200: true,
        201: true,
        404: 'no such container',
        409: 'container is paused',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, conf) => {
        if (err) return reject(err)
        const exec = new Exec(this.modem, this.container, conf.Id)
        exec.data = conf
        resolve(exec)
      })
    })
  }

  /**
   * Start an exec instance
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/exec-start
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise return the stream to the execution
   */
  start (opts: any = {}): Promise<Object> {
    const call = {
      path: `/exec/${this.id}/start?`,
      method: 'POST',
      options: opts,
      isStream: true,
      hijack: opts.hijack,
      openStdin: opts.stdin,
      statusCodes: {
        200: true,
        404: 'no such exec instance',
        409: 'container is paused'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, stream: Object) => {
        if (err) return reject(err)
        resolve(stream)
      })
    })
  }

  /**
   * Resize an exec instance
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/exec-resize
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise return the result
   */
  resize (opts?: Object): Promise<{}> {
    const call = {
      path: `/exec/${this.id}/resize?`,
      method: 'POST',
      options: opts,
      statusCodes: {
        201: true,
        404: 'no such exec instance'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err) => {
        if (err) return reject(err)
        resolve()
      })
    })
  }

  /**
   * Get status of an exec instance
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/exec-inspect
   * The reason why this module isn't called inspect is because that interferes with the inspect utility of node.
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise return the exec instance
   */
  status (opts?: Object): Promise<Exec> {
    const call = {
      path: `/exec/${this.id}/json?`,
      method: 'GET',
      options: opts,
      statusCodes: {
        200: true,
        404: 'no such exec instance',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, conf) => {
        if (err) return reject(err)
        const exec = new Exec(this.modem, this.container, conf.Id)
        exec.data = conf
        resolve(exec)
      })
    })
  }
}

/**
 * Class representing container execution management
 */
export class ExecManager {
  modem: Modem
  container: Container

  /**
   * Create an execution
   * @param  {Modem}      modem     Modem to connect to the remote service
   * @param  {Container}  container Container that owns the execution (optional)
   * @param  {string}     id        Id of the execution
   */

  constructor (modem: Modem, container: Container) {
    this.modem = modem
    this.container = container
  }

  /**
   * Get a Exec Object
   * @param  {id}         string    ID of the exec
   * @return {Exec}
   */
  get (id: string): Exec {
    return new Exec(this.modem, this.container, id)
  }

  /**
   * Create an exec instance in a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/create-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise return the new exec instance
   */
  create (opts?: Object): Promise<Exec> {
    const call = {
      path: `/containers/${this.container.id}/exec?`,
      method: 'POST',
      options: opts,
      statusCodes: {
        200: true,
        201: true,
        404: 'no such container',
        409: 'container is paused',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, conf) => {
        if (err) return reject(err)
        const exec = new Exec(this.modem, this.container, conf.Id)
        exec.data = conf
        resolve(exec)
      })
    })
  }
}

/**
 * Class representing container filesystem
 */
export class ContainerFs {
  modem: Modem
  container: Container

  /**
   * Create an container filesystem Object
   * @param  {Modem}      modem     Modem to connect to the remote service
   * @param  {Container}  container Container that owns the filesystem (optional)
   */
  constructor (modem: Modem, container: Container) {
    this.modem = modem
    this.container = container
  }

  /**
   * Get the info about the filesystem of the container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/retrieving-information-about-files-and-folders-in-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise returning the info about the filesystem
   */
  info (opts?: Object): Promise<String> {
    const call = {
      path: `/containers/${this.container.id}/archive?`,
      method: 'HEAD',
      isStream: true,
      options: opts,
      statusCodes: {
        200: true,
        404: 'bad request',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, info: string) => {
        if (err) return reject(err)
        resolve(info)
      })
    })
  }

  /**
   * Get a tar archive of a resource in the filesystem of a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/get-an-archive-of-a-filesystem-resource-in-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise returning the result as a stream to the tar file
   */
  get (opts: any = {}): Promise<Object> {
    const call = {
      path: `/containers/${this.container.id}/archive?path=${opts.path}&`,
      method: 'GET',
      isStream: true,
      options: opts,
      statusCodes: {
        200: true,
        400: 'bad request',
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, stream: Object) => {
        if (err) return reject(err)
        resolve(stream)
      })
    })
  }

  /**
   * Put an extracted tar archive in the filesystem of a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/extract-an-archive-of-files-or-folders-to-a-directory-in-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise returning the result
   */
  put (file: fs.ReadStream, opts?: Object): Promise<Object> {
    const call = {
      path: `/containers/${this.container.id}/archive?`,
      method: 'PUT',
      options: opts,
      isStream: true,
      file: file,
      statusCodes: {
        200: true,
        400: 'bad request',
        403: 'permission denied',
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, res: Object) => {
        if (err) return reject(err)
        resolve(res)
      })
    })
  }
}

/**
 * Class representing a container
 */
export class Container {
  modem: Modem
  id: string
  fs: ContainerFs
  exec: ExecManager
  Warnings: Array<String> = []
  data: Object = {}

  /**
   * Create an container Object
   * @param  {Modem}  modem Modem to connect to the remote service
   * @param  {string} id    Container id
   */
  constructor (modem: Modem, id: string) {
    this.modem = modem
    this.id = id
    this.fs = new ContainerFs(this.modem, this)
    this.exec = new ExecManager(this.modem, this)
  }

  /**
   * Get low-level information on a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/inspect-a-container
   * The reason why this module isn't called inspect is because that interferes with the inspect utility of node.
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise return the container
   */
  status (opts?: Object): Promise<Container> {
    const call = {
      path: `/containers/${this.id}/json?`,
      method: 'GET',
      options: opts,
      statusCodes: {
        200: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, conf) => {
        if (err) return reject(err)
        const container = new Container(this.modem, this.id)
        container.data = conf
        resolve(container)
      })
    })
  }

  /**
   * Get list of processes (ps) inside a container. Not supported in Windows.
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/list-processes-running-inside-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise return the list of processes
   */
  top (opts?: Object): Promise<Array<Object>> {
    const call = {
      path: `/containers/${this.id}/top?`,
      method: 'GET',
      options: opts,
      statusCodes: {
        200: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, processes: Array<Object>) => {
        if (err) return reject(err)
        resolve(processes)
      })
    })
  }

  /**
   * Get stdout and stderr logs from a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/get-container-logs
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise returning the concatenated logs
   */
  logs (opts?: Object): Promise<Object> {
    const call = {
      path: `/containers/${this.id}/logs?`,
      method: 'GET',
      options: opts,
      isStream: true,
      statusCodes: {
        101: true,
        200: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, logs: Object) => {
        if (err) return reject(err)
        resolve(logs)
      })
    })
  }

  /**
   * Get changes on a container's filesystem
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/inspect-changes-on-a-container-s-filesystem
   * @return {Promise}        Promise returning the changes
   */
  changes (): Promise<Array<Object>> {
    const call = {
      path: `/containers/${this.id}/changes?`,
      method: 'GET',
      options: {},
      statusCodes: {
        200: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, changes: Array<Object>) => {
        if (err) return reject(err)
        resolve(changes)
      })
    })
  }

  /**
   * Export the content of a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/export-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the content of the tar file as a stream or as a string
   */
  export (opts: any = {}): Promise<Object> {
    const call = {
      path: `/containers/${this.id}/export?`,
      method: 'GET',
      options: opts,
      isStream: !!opts.stream,
      statusCodes: {
        200: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, tarStream: any) => {
        if (err) return reject(err)
        if (!opts.stream) return resolve(tarStream)

        const res = []
        tarStream.on('data', (chunk) => {
          res.push(chunk.toString())
        })

        tarStream.on('end', () => {
          resolve(res.join(''))
        })
      })
    })
  }

  /**
   * Get the stats of a container, either by a live stream or the current state
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/export-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the stats, in a stream or string
   */
  stats (opts?: Object): Promise<Object> {
    const call = {
      path: `/containers/${this.id}/stats?`,
      method: 'GET',
      options: opts,
      isStream: true,
      statusCodes: {
        200: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, stats: Object) => {
        if (err) return reject(err)
        resolve(stats)
      })
    })
  }

  /**
   * Resize the TTY for a container. You must restart the container to make the resize take effect.
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/resize-a-container-tty
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the response
   */
  resize (opts?: Object): Promise<Object> {
    const call = {
      path: `/containers/${this.id}/resize?`,
      method: 'GET',
      options: opts,
      statusCodes: {
        200: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, res: Object) => {
        if (err) return reject(err)
        resolve(res)
      })
    })
  }

  /**
   * Start a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/start-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the container
   */
  start (opts: Object = {}): Promise<Container> {
    const call = {
      path: `/containers/${this.id}/start?`,
      method: 'POST',
      options: opts,
      statusCodes: {
        204: true,
        304: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err) => {
        if (err) return reject(err)
        resolve(this)
      })
    })
  }

  /**
   * Stop a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/stop-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the container
   */
  stop (opts?: Object): Promise<Container> {
    const call = {
      path: `/containers/${this.id}/stop?`,
      method: 'POST',
      options: opts,
      statusCodes: {
        204: true,
        304: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err) => {
        if (err) return reject(err)
        resolve(this)
      })
    })
  }

  /**
   * Restart a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/restart-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the container
   */
  restart (opts?: Object): Promise<Container> {
    const call = {
      path: `/containers/${this.id}/restart?`,
      method: 'POST',
      options: opts,
      statusCodes: {
        204: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err) => {
        if (err) return reject(err)
        resolve(this)
      })
    })
  }

  /**
   * Kill a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/kill-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the container
   */
  kill (opts?: Object): Promise<Container> {
    const call = {
      path: `/containers/${this.id}/kill?`,
      method: 'POST',
      options: opts,
      statusCodes: {
        204: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err) => {
        if (err) return reject(err)
        resolve(this)
      })
    })
  }

  /**
   * Update configuration a container.
   * Docs says you can do it for more than one, but doesn't exaplin how, so let's leave it in only one
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/update-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the container
   */
  update (opts?: Object): Promise<Container> {
    const call = {
      path: `/containers/${this.id}/update?`,
      method: 'POST',
      options: opts,
      statusCodes: {
        200: true,
        400: 'bad request',
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, warnings: Array<String>) => {
        const container = new Container(this.modem, this.id)
        container.Warnings = warnings
        if (err) return reject(err)
        resolve(container)
      })
    })
  }

  /**
   * Rename a container.
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/rename-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the container
   */
  rename (opts: Object): Promise<Container> {
    const call = {
      path: `/containers/${this.id}/rename?`,
      method: 'POST',
      options: opts,
      statusCodes: {
        204: true,
        404: 'no such container',
        409: 'name already taken',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err) => {
        if (err) return reject(err)
        resolve(this)
      })
    })
  }

  /**
   * Pause a container.
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/pause-a-container
   * @return {Promise}          Promise returning the container
   */
  pause (): Promise<Container> {
    const call = {
      path: `/containers/${this.id}/pause?`,
      method: 'POST',
      options: {},
      statusCodes: {
        204: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err) => {
        if (err) return reject(err)
        resolve(this)
      })
    })
  }

  /**
   * Unpause a container.
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/unpause-a-container
   * @return {Promise}          Promise returning the container
   */
  unpause (): Promise<Container> {
    const call = {
      path: `/containers/${this.id}/unpause?`,
      method: 'POST',
      options: {},
      statusCodes: {
        204: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err) => {
        if (err) return reject(err)
        resolve(this)
      })
    })
  }

  /**
   * Attach to a container.
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/attach-to-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the container
   */
  attach (opts: any = {}): Promise<Array<Object>> {
    const call = {
      path: `/containers/${this.id}/attach?`,
      method: 'POST',
      isStream: true,
      openStdin: opts.stdin,
      options: opts,
      statusCodes: {
        101: true,
        200: true,
        400: 'bad request',
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, stream) => {
        if (err) return reject(err)
        resolve([ stream, this ])
      })
    })
  }

  /**
   * Attach to a container using websocket.
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/attach-to-a-container-websocket
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the stream and the container
   */
  wsattach (opts?: Object): Promise<Array<Object>> {
    const call = {
      path: `/containers/${this.id}/attach/ws?`,
      method: 'GET',
      options: opts,
      statusCodes: {
        200: true,
        400: 'bad request',
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, stream) => {
        if (err) return reject(err)
        resolve([ stream, this ])
      })
    })
  }

  /**
   * Block until a container stops, returning exit code
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/wait-a-container
   * @return {Promise}          Promise returning the exit code
   */
  wait (): Promise<Number> {
    const call = {
      path: `/containers/${this.id}/wait?`,
      method: 'POST',
      options: {},
      statusCodes: {
        200: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, code: number) => {
        if (err) return reject(err)
        resolve(code)
      })
    })
  }

  /**
   * Remove a container.
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/remove-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning nothing
   */
  delete (opts?: Object): Promise<{}> {
    const call = {
      path: `/containers/${this.id}?`,
      method: 'DELETE',
      options: opts,
      statusCodes: {
        204: true,
        400: 'bad request',
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err) => {
        if (err) return reject(err)
        resolve()
      })
    })
  }

  /**
   * Commit container into an image
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/create-a-new-image-from-a-container-s-changes
   * @param  {Object}   opts    Query params in the request (optional)
   * @return {Promise}          Promise returning the new image
   */
  commit (opts: any = {}): Promise<Image> {
    opts.container = this.id

    const call = {
      path: `/commit?`,
      method: 'POST',
      options: opts,
      statusCodes: {
        201: true,
        404: 'no such container',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, res) => {
        if (err) return reject(err)
        resolve(new Image(this.modem, res.Id.replace('sha256:', '')))
      })
    })
  }
}

export default class {
  modem: Modem

  constructor(modem: Modem) {
    this.modem = modem
  }

  /**
   * Get a Container Object
   * @param  {id}         string    ID of the container
   * @return {Container}
   */
  get (id: string): Container {
    return new Container(this.modem, id)
  }

  /**
   * Get the list of containers
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/list-containers
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise returning the result as a list of containers
   */
  list (opts?: Object): Promise<Array<Container>> {
    const call = {
      path: '/containers/json?',
      method: 'GET',
      options: opts,
      statusCodes: {
        200: true,
        400: 'bad request',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, containers) => {
        if (err) return reject(err)
        resolve(containers.map((conf) => {
          const container = new Container(this.modem, conf.Id)
          container.data = conf
          return container
        }))
      })
    })
  }

  /**
   * Create a container
   * https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/create-a-container
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}        Promise return the new container
   */
  create (opts?: Object): Promise<Container> {
    const call = {
      path: '/containers/create?',
      method: 'POST',
      options: opts,
      statusCodes: {
        200: true,
        201: true,
        400: 'bad request',
        404: 'no such image',
        406: 'impossible to attach',
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, conf) => {
        if (err) return reject(err)
        const container = new Container(this.modem, conf.Id)
        container.data = conf
        resolve(container)
      })
    })
  }

  /**
   * Prune a container
   * https://docs.docker.com/engine/api/v1.25/#operation/ContainerPrune
   * @param  {Object}   opts  Query params in the request (optional)
   * @return {Promise}          Promise returning the container
   */
  prune (opts?: Object): Promise<Object> {
    const call = {
      path: `/containers/prune`,
      method: 'POST',
      options: opts,
      statusCodes: {
        200: true,
        500: 'server error'
      }
    }

    return new Promise((resolve, reject) => {
      this.modem.dial(call, (err, res: Object) => {
        if (err) return reject(err)
        resolve(res)
      })
    })
  }
}