import ajax from './ajax-request'
import {ConfigureFn, AjaxResponse, AjaxError} from './ajax-request'
import FileRecord from './file-record'

type ProgressFn = (event: ProgressEvent) => void
export type CreateFormDataFn = (fileRecord: FileRecord) => FormData

export interface TusOptions {
  retryDelays?: number[]
  metadata?: any
}

export type TusOptionsFn = (fileRecord: FileRecord) => TusOptions

class UploadHelper {
  public addHeaders(xhr: XMLHttpRequest, headers: object): XMLHttpRequest {
    xhr.setRequestHeader('Accept', 'application/json')
    if (headers) {
      for (const key in headers) {
        if (headers.hasOwnProperty(key)) {
          xhr.setRequestHeader(key, (headers as any)[key])
        }
      }
    }
    return xhr
  }

  public doUpload(
    url: string,
    headers: object,
    formData: FormData,
    progressCallback: ProgressFn,
    configureFn?: ConfigureFn
  ): Promise<AjaxResponse> {
    return ajax.post(url, formData, (xhr) => {
      this.addHeaders(xhr, headers)
      xhr.upload.addEventListener('progress', progressCallback, false)
      if (typeof configureFn === 'function') {
        configureFn(xhr)
      }
    })
  }

  public doDeleteUpload(
    url: string,
    headers: object,
    uploadData: any,
    configureFn?: ConfigureFn
  ): Promise<AjaxResponse> {
    if (typeof uploadData !== 'string') {
      uploadData = JSON.stringify(uploadData)
    }
    return ajax.delete(url, uploadData, (xhr) => {
      xhr.setRequestHeader('Content-Type', 'application/json')
      this.addHeaders(xhr, headers)
      if (typeof configureFn === 'function') {
        configureFn(xhr)
      }
    })
  }

  public doUpdateUpload(
    url: string,
    headers: object,
    uploadData: any,
    configureFn?: ConfigureFn
  ): Promise<AjaxResponse> {
    if (typeof uploadData !== 'string') {
      uploadData = JSON.stringify(uploadData)
    }
    return ajax.put(url, uploadData, (xhr) => {
      xhr.setRequestHeader('Content-Type', 'application/json')
      this.addHeaders(xhr, headers)
      if (typeof configureFn === 'function') {
        configureFn(xhr)
      }
    })
  }

  // doUploadAxios(axios, formData, progressCallback){
  //   return axios.post('/upload', formData, {
  //     onUploadProgress: progressCallback,
  //   });
  // }

  // doDeleteUploadAxios(axios, data, configureFn){
  //   return axios.delete('/upload', data, {
  //   });
  // }

  public prepareUploadError(fileRecord: FileRecord, err: AjaxError, timeout?: number) {
    let errorText = err.message
    if (err.response && err.response.data) {
      try {
        const errorMsg = err.response.data.error || JSON.parse(err.response.data).error
        errorText = errorMsg
      } catch (e) {
        // ignore
      }
    }
    if (!fileRecord.error) {
      fileRecord.error = {}
    }
    fileRecord.error.upload = errorText
    fileRecord.upload.data = undefined
    fileRecord.upload.error = errorText
    if (timeout) {
      window.setTimeout(() => {
        if (!fileRecord.error) {
          fileRecord.error = {}
        }
        fileRecord.error.upload = false
        if (!fileRecord.error.size && !fileRecord.error.type) {
          fileRecord.error = false
        }
      }, timeout)
    }
  }

  public upload(
    url: string,
    headers: object,
    fileRecords: FileRecord[],
    createFormData?: CreateFormDataFn,
    progressFn?: (progress: number) => void,
    configureFn?: ConfigureFn
  ) {
    let updateOverallProgress = () => {
      /* no op */
    }
    if (progressFn) {
      updateOverallProgress = () => {
        let prgTotal = 0
        for (const fileRecord of fileRecords) {
          prgTotal += fileRecord.progress() as number
        }
        progressFn(prgTotal / fileRecords.length)
      }
    }
    const promises: Array<Promise<AjaxResponse | AjaxError>> = []
    let failedUploadsCount = 0
    for (const fileRecord of fileRecords) {
      let formData
      if (typeof createFormData === 'function') {
        formData = createFormData(fileRecord)
      } else {
        formData = new FormData()
        formData.append('file', fileRecord.file as File)
        formData.append('filename', fileRecord.name())
      }
      const promise = this.doUpload(
        url,
        headers,
        formData,
        (progressEvent) => {
          const percentCompleted = (progressEvent.loaded * 100) / progressEvent.total
          // do not complete until promise resolved
          fileRecord.progress(percentCompleted >= 100 ? 99.9999 : percentCompleted)
          updateOverallProgress()
        },
        (xhr) => {
          fileRecord.xhr = xhr
          if (typeof configureFn === 'function') {
            configureFn(xhr)
          }
        }
      )
      promises.push(
        new Promise((resolve, reject) => {
          promise.then(
            (response) => {
              delete fileRecord.xhr
              fileRecord.upload.data = response.data
              fileRecord.upload.error = false
              fileRecord.progress(100)
              if (fileRecord.xhrQueue) {
                fileRecord.xhrQueue()
                delete fileRecord.xhrQueue
              }
              resolve(response)
            } /* */,
            (err) => {
              this.prepareUploadError(fileRecord, err)
              resolve(err)
              failedUploadsCount++
            } /* */
          )
        })
      )
    }
    // return Promise.all(promises);
    return new Promise((resolve, reject) => {
      Promise.all(promises).then((responses) => {
        if (failedUploadsCount === promises.length) {
          // all uploads failed
          reject(responses)
          return
        }
        resolve(responses)
      }, reject)
    })
  }

  public deleteUpload(
    url: string,
    headers: object,
    fileRecord: FileRecord,
    uploadData?: any,
    configureFn?: ConfigureFn
  ) {
    return new Promise((resolve, reject) => {
      if (fileRecord.xhr) {
        fileRecord.xhr.abort()
      }
      if (uploadData === undefined) {
        uploadData = fileRecord.upload.data
      }
      if (uploadData) {
        this.doDeleteUpload(url, headers, uploadData, (xhr) => {
          if (typeof configureFn === 'function') {
            configureFn(xhr)
          }
        }).then(
          (result) => {
            resolve(result)
          },
          (err) => {
            this.prepareUploadError(fileRecord, err)
            reject(err)
          }
        )
      }
    })
  }

  public updateUpload(
    url: string,
    headers: object,
    fileRecord: FileRecord,
    uploadData: any,
    configureFn?: ConfigureFn
  ) {
    return new Promise((resolve, reject) => {
      if (fileRecord.xhr) {
        // probably updated while being uploaded.
        fileRecord.xhrQueue = () => {
          this.updateUpload(url, headers, fileRecord, uploadData)
        }
        return resolve(undefined)
      }
      if (uploadData === undefined) {
        uploadData = fileRecord.upload.data || {}
        uploadData.old_filename = fileRecord.oldFileName
        uploadData.filename = fileRecord.name()
      }
      if (uploadData) {
        this.doUpdateUpload(url, headers, uploadData, (xhr) => {
          if (typeof configureFn === 'function') {
            configureFn(xhr)
          }
        }).then(
          (response) => {
            fileRecord.upload.data = response.data
            fileRecord.upload.error = false
            resolve(response)
          },
          (err) => {
            this.prepareUploadError(fileRecord, err)
            reject(err)
          }
        )
      }
    })
  }

  public doTusUpload(
    tus: any,
    url: string,
    fileRecord: FileRecord,
    headers: object,
    progressCallback: ProgressFn,
    tusOptionsFn?: TusOptionsFn,
    uploadWithCredentials?: boolean
  ) {
    const tusOptions: TusOptions = tusOptionsFn ? tusOptionsFn(fileRecord) : {}
    return new Promise((resolve, reject) => {
      if (!tus) {
        return reject(new Error('tus required. Please install tus-js-client'))
      }
      // https://github.com/tus/tus-js-client
      // Create a new tus upload
      const file = fileRecord.file
      const upload = new tus.Upload(file, {
        endpoint: url,
        headers,
        retryDelays: tusOptions.retryDelays
          ? tusOptions.retryDelays
          : [0, 3000, 5000, 10000, 20000],
        metadata: tusOptions.metadata
          ? tusOptions.metadata
          : {
              filename: file.name,
              filetype: file.type,
            },
        onError(error: any) {
          reject(error)
          // console.log("Failed because: " + error)
        },
        onProgress(bytesUploaded: number, bytesTotal: number) {
          const event = {loaded: bytesUploaded, total: bytesTotal} as ProgressEvent
          progressCallback(event)
        },
        onSuccess() {
          resolve(upload)
        },
        onBeforeRequest: function (req: any) {
          const xhr: XMLHttpRequest = req.getUnderlyingObject()
          xhr.withCredentials = uploadWithCredentials === true
        },
      })
      fileRecord.tusUpload = upload
      // Start the upload
      upload.start()
    })
  }

  public tusUpload(
    tus: any,
    url: string,
    headers: object,
    fileRecords: FileRecord[],
    progressFn?: (progress: number) => void,
    tusOptionsFn?: TusOptionsFn,
    uploadWithCredentials?: boolean
  ) {
    let updateOverallProgress = () => {
      /* no op */
    }
    if (progressFn) {
      updateOverallProgress = () => {
        let prgTotal = 0
        for (const fileRecord of fileRecords) {
          prgTotal += fileRecord.progress() as number
        }
        progressFn(prgTotal / fileRecords.length)
      }
    }
    const promises = []
    for (const fileRecord of fileRecords) {
      const promise = this.doTusUpload(
        tus,
        url,
        fileRecord,
        headers,
        (progressEvent: ProgressEvent) => {
          const percentCompleted = (progressEvent.loaded * 100) / progressEvent.total
          // do not complete until promise resolved
          fileRecord.progress(percentCompleted >= 100 ? 99.9999 : percentCompleted)
          updateOverallProgress()
        },
        tusOptionsFn,
        uploadWithCredentials
      )
      promise.then(
        (response) => {
          // delete fileRecord.tusUpload;
          fileRecord.progress(100)
        },
        (err) => {
          this.prepareUploadError(fileRecord, err)
        }
      )
      promises.push(promise)
    }
    return Promise.all(promises)
  }

  public tusDeleteUpload(tus: any, url: string, headers: object, fileRecord: FileRecord) {
    return new Promise((resolve, reject) => {
      if (!tus) {
        return reject('tus required')
      }
      if (!fileRecord.tusUpload) {
        return resolve(undefined)
      }
      // const shouldTerminate = true;
      const abort = (shouldTerminate: boolean) => {
        return new Promise((res, rej) => {
          fileRecord.tusUpload.abort(shouldTerminate, (err: any) => {
            if (err) {
              this.prepareUploadError(fileRecord, err)
              rej(err)
              return
            }
            res(undefined)
          })
        })
      }
      abort(false).then(() => {
        window.setTimeout(() => {
          abort(true).then(resolve, reject)
        }, 1000)
      })
    })
  }
}

export default new UploadHelper()