import { invoke, transformCallback } from '@tauri-apps/api/tauri'

interface CheckOptions {
  /**
   * Request headers
   */
  headers?: Record<string, unknown>
  /**
   * Timeout in seconds
   */
  timeout?: number
  /**
   * Target identifier for the running application. This is sent to the backend.
   */
  target?: string
}

interface UpdateResponse {
  available: boolean
  currentVersion: string
  latestVersion: string
  date?: string
  body?: string
}

// TODO: use channel from @tauri-apps/api on v2
class Channel<T = unknown> {
  id: number
  // @ts-expect-error field used by the IPC serializer
  private readonly __TAURI_CHANNEL_MARKER__ = true
  #onmessage: (response: T) => void = () => {
    // no-op
  }

  constructor() {
    this.id = transformCallback((response: T) => {
      this.#onmessage(response)
    })
  }

  set onmessage(handler: (response: T) => void) {
    this.#onmessage = handler;
  }

  get onmessage(): (response: T) => void {
    return this.#onmessage
  }

  toJSON(): string {
    return `__CHANNEL__:${this.id}`
  }
}

type DownloadEvent =
  { event: 'Started', data: { contentLength?: number } } |
  { event: 'Progress', data: { chunkLength: number } } |
  { event: 'Finished' }

class Update {
  response: UpdateResponse

  constructor(response: UpdateResponse) {
    this.response = response
  }

  async downloadAndInstall(onEvent?: (progress: DownloadEvent) => void): Promise<void> {
    const channel = new Channel<DownloadEvent>()
    if (onEvent != null) {
      channel.onmessage = onEvent
    }
    return invoke('plugin:updater|download_and_install', { onEvent: channel })
  }
}

async function check(options?: CheckOptions): Promise<Update> {
  return invoke<UpdateResponse>('plugin:updater|check', { ...options }).then(response => new Update(response))
}

export type { CheckOptions, UpdateResponse, DownloadEvent }
export { check, Update }