import {getIconFromExt, SvgIcon} from './icons'
import utils from './utils'
import {RGBA, ImageThumbnail, VideoThumbnail} from './utils'

interface Dimensions {
  height: number
  width: number
}

interface Options {
  accept?: string
  maxSize?: string
  read: boolean
  thumbnailSize?: number
  averageColor?: boolean
  withCredentials?: boolean
}

interface ErrorText {
  common?: string
  type?: string
  size?: string
  upload?: string
}

interface ErrorFlags {
  common?: boolean
  type?: boolean
  size?: boolean
  upload?: false | string
}

interface RawFileRecord {
  url: string | undefined
  urlResized: string | null
  src: string
  name: string
  lastModified: number
  sizeText: string
  size: number
  type: string
  ext: string
  color: string
  file: File
  progress: number
  error?: false | ErrorFlags
  dimensions: Dimensions
  videoThumbnail: string
  imageColor: RGBA
  customName: string
  upload: UploadData
}

interface DummyFile {
  name: string
  size: number
  type: string
  lastModified: number
  lastModifiedDate: Date
}

interface UploadData {
  data: any
  error: string | false
}

export type {Dimensions, ErrorText, Options, RawFileRecord}

class FileRecord {
  public static getFromRaw(
    rawFileRecord: RawFileRecord,
    options: Options,
    isSync: boolean
  ): Promise<FileRecord> | FileRecord {
    const fileRecord = new FileRecord(rawFileRecord, options)
    const promise = fileRecord.setUrl(rawFileRecord.url as string)
    if (isSync) {
      return fileRecord
    }
    return promise
  }

  public static fromRaw(rawFileRecord: RawFileRecord, options: Options): Promise<FileRecord> {
    return FileRecord.getFromRaw(rawFileRecord, options, false) as Promise<FileRecord>
  }

  public static fromRawSync(rawFileRecord: RawFileRecord, options: Options): FileRecord {
    return FileRecord.getFromRaw(rawFileRecord, options, true) as FileRecord
  }

  public static fromRawArray(
    rawFileRecords: RawFileRecord[],
    options: Options
  ): Promise<FileRecord[]> {
    const promises: Array<Promise<FileRecord>> = []
    for (const rawFileRecord of rawFileRecords) {
      promises.push(FileRecord.fromRaw(rawFileRecord, options))
    }
    return Promise.all(promises)
  }

  public static fromRawArraySync(rawFileRecords: RawFileRecord[], options: Options): FileRecord[] {
    const fileRecords: Array<FileRecord> = []
    for (const rawFileRecord of rawFileRecords) {
      fileRecords.push(FileRecord.fromRawSync(rawFileRecord, options))
    }
    return fileRecords
  }

  public static toRawArray(fileRecords: FileRecord[]): RawFileRecord[] {
    const rawFileRecords: RawFileRecord[] = []
    for (const fileRecord of fileRecords) {
      rawFileRecords.push(fileRecord.toRaw())
    }
    return rawFileRecords
  }

  public static readFile(fileRecord: FileRecord): Promise<FileRecord> {
    return new Promise((resolve, reject) => {
      if (!fileRecord.read) {
        fileRecord.setUrl(null).then(
          () => {
            resolve(fileRecord)
          },
          (err) => {
            // ignore error
            resolve(fileRecord)
          }
        )
        return
      }
      utils.getDataURL(fileRecord.file).then((dataUrl) => {
        fileRecord.setUrl(dataUrl).then(() => {
          resolve(fileRecord)
        }, reject)
      }, reject)
    })
  }

  public static readFiles(fileRecords: FileRecord[]): Promise<FileRecord[]> {
    const promises: Array<Promise<FileRecord>> = []
    for (const fileRecord of fileRecords) {
      promises.push(FileRecord.readFile(fileRecord))
    }
    return Promise.all(promises)
  }

  public urlValue: null | string = null
  public urlResized: null | string = null
  public image: HTMLImageElement | {} = {}
  public isPlayingAv: boolean = false

  public oldFileName: string | null = null
  public oldCustomName: string | null = null
  public upload: UploadData = {data: null, error: false}

  public raw: RawFileRecord
  public progressInternal: number
  public accept?: string
  public dimensions: Dimensions
  public error: false | ErrorFlags
  public file: File
  public height: undefined | number | string
  public width: undefined | number | string
  public id: string
  public imageColor?: RGBA
  public lastKnownSrc: null | string
  public maxSize?: string
  public options: Options
  public read: boolean
  public thumbnailSize: number
  public videoThumbnail: any
  public customName: any
  public xhr?: XMLHttpRequest
  public xhrQueue?: () => any
  public stopAv?: (() => any) | null
  public tusUpload?: any
  public calculateAverageColor: boolean

  public constructor(data: RawFileRecord, options: Options) {
    this.urlValue = null
    this.urlResized = null
    this.lastKnownSrc = null
    this.image = {}
    this.isPlayingAv = false
    this.oldFileName = null
    this.oldCustomName = null

    this.raw = data
    this.file = data.file instanceof File ? data.file : (this.createDummyFile(data) as any)
    this.progressInternal = !isNaN(data.progress as number) ? (data.progress as number) : 0
    // this.width = FileRecord.defaultWidth;
    // this.height = FileRecord.defaultHeight;
    this.thumbnailSize = options.thumbnailSize || 360
    this.read = !!options.read
    this.dimensions = data.dimensions || {width: 0, height: 0}
    this.dimensions.width = this.dimensions.width || 0
    this.dimensions.height = this.dimensions.height || 0
    this.error = data.error || false
    this.options = options
    this.maxSize = options.maxSize
    this.accept = options.accept
    this.id = Math.random() + ':' + new Date().getTime()
    this.videoThumbnail = data.videoThumbnail
    this.imageColor = data.imageColor
    this.customName = data.customName
    this.calculateAverageColor = options.averageColor !== undefined ? options.averageColor : true
    this.validate()
  }

  public createDummyFile(data: RawFileRecord): DummyFile {
    const file: DummyFile = {} as DummyFile
    file.lastModified = data.lastModified
    const d = new Date()
    if (file.lastModified) {
      d.setTime(file.lastModified)
    }
    file.lastModifiedDate = d
    file.name = data.name
    file.size = data.size
    file.type = data.type
    return file
  }

  public hasProgress(): boolean {
    return !isNaN(this.progressInternal) // && this._progress <= 100;
  }

  progress(value: number): void
  progress(): number
  public progress(value?: number): number | void {
    if (value !== undefined) {
      this.progressInternal = value
      return
    }
    return this.progressInternal
  }

  url(value: string): string | undefined | Promise<this>
  url(): string | undefined
  public url(value?: string): string | undefined | Promise<this> {
    if (value !== undefined) {
      return this.setUrl(value)
    }
    return this.urlValue || undefined
  }

  public src(): string {
    if (this.isImage()) {
      return this.urlResized || this.urlValue || (this.file as any).url
    }
    if (this.isPlayableVideo()) {
      return this.videoThumbnail || ''
    }
    return ''
  }

  public size(): string {
    if (!this.file) {
      return ''
    }
    return utils.getSizeFormatted(this.file.size)
  }

  public ext(): string {
    if (this.file && this.file.name.indexOf('.') !== -1) {
      return (this.file.name as any).split('.').pop()
    }
    return '?'
    // return this.file.type.split('/').shift();
  }

  public name(withoutExt?: boolean): string {
    const ext = this.ext()
    if (this.customName) {
      return this.customName + (withoutExt ? '' : ext !== '?' ? '.' + ext : '')
    }
    const name = this.file && this.file.name
    if (withoutExt) {
      if (ext !== '?') {
        return name.substr(0, name.length - (ext.length + 1))
      }
    }
    return name
  }

  public isDarkColor(): boolean {
    if (this.imageColor) {
      const rgb = this.imageColor
      const darkPoint = 20
      return rgb[0] <= darkPoint && rgb[1] <= darkPoint && rgb[2] <= darkPoint
    }
    return false
  }

  public color(): string {
    if (this.imageColor) {
      const rgb = this.imageColor
      return 'rgb(' + rgb[0] + ', ' + rgb[1] + ', ' + rgb[2] + ')'
    }
    if (this.isImage()) {
      return 'transparent'
    }
    const ext = this.ext()
    const svgIcon = this.icon()
    // var svgIcon = getIconFromExt(ext);
    if (svgIcon.color) {
      return svgIcon.color
    }
    return utils.getColorForText(ext)
  }

  public isImage(): boolean {
    return (
      this.file && this.file.type !== 'image/x-wmf' && !!this.file.type.match(/image((?!vnd).)*$/i)
    )
  }

  public isVideo(): boolean {
    return this.file && this.file.type.indexOf('video') !== -1
  }

  public isPlayableVideo(): boolean {
    return this.icon().category === 'video-playable'
  }

  public isAudio(): boolean {
    return this.file && this.file.type.indexOf('audio') !== -1
  }

  public isPlayableAudio(): boolean {
    return this.icon().category === 'audio-playable'
  }

  public isText(): boolean {
    return this.file && this.file.type.indexOf('text') !== -1
  }

  public setUrl(url: string | null): Promise<this> {
    this.urlValue = url
    return new Promise((resolve, reject) => {
      if (this.isImage()) {
        this.resizeImage().then(
          () => {
            resolve(this)
          },
          (err) => {
            resolve(this)
          }
        )
        return
      }
      resolve(this)
    })
  }

  public imageResized(resized: ImageThumbnail | null) {
    if (!resized) {
      return
    }
    this.urlResized = resized.url
    this.image = resized.image
    if (resized.image && resized.image.width && resized.image.height) {
      this.dimensions.width = resized.image.width
      this.dimensions.height = resized.image.height
    }
    this.lastKnownSrc = this.urlResized
    this.imageColor = resized.color
  }

  public resizeImage(): Promise<this> {
    return new Promise((resolve, reject) => {
      utils
        .resizeImage(
          this.thumbnailSize,
          this.file,
          this.urlValue as string,
          this.calculateAverageColor
        )
        .then((resized) => {
          this.imageResized(resized)
          resolve(this)
        })
        .catch(reject)
    })
  }

  public icon(): SvgIcon {
    const ext = this.ext()
    const svgIcon = getIconFromExt(ext)
    return svgIcon
  }

  public getErrorMessage(errorText?: ErrorText): string {
    const error = this.error
    if (!error) {
      return ''
    }
    errorText = errorText || {}
    errorText = {
      common: errorText.common || 'Invalid file.',
      type: errorText.type || 'Invalid file type.',
      size: errorText.size || 'Files should not exceed ' + this.maxSize + ' in size',
    }
    if (error.type) {
      return errorText.type as string
    } else if (error.size) {
      return errorText.size as string
    } else if (error.upload) {
      return this.upload.error ? this.upload.error : error.upload
    }
    return errorText.common as string
  }

  public toRaw(): RawFileRecord {
    const raw = this.raw || ({} as RawFileRecord)
    raw.url = this.url()
    raw.urlResized = this.urlResized
    raw.src = this.src()
    raw.name = this.name()
    raw.lastModified = this.file.lastModified
    raw.sizeText = this.size()
    raw.size = this.file.size
    raw.type = this.file.type
    raw.ext = this.ext()
    raw.color = this.color()
    raw.file = this.file
    raw.progress = this.progress() // pass it as a function
    raw.upload = this.upload
    if (!('error' in raw)) {
      Object.defineProperty(raw, 'error', {
        get: () => {
          return this.error
        },
      })
    }
    raw.dimensions = this.dimensions
    return raw
  }

  public validate(): void {
    const validType = utils.validateType(this.file, this.accept)
    const validSize = utils.validateSize(this.file, this.maxSize as string)
    if (!validType || !validSize) {
      this.error = {
        type: !validType,
        size: !validSize,
      }
    } else {
      this.error = false
    }
  }
}

export default FileRecord