import * as Axios from 'axios'
import * as Bluebird from 'bluebird'
import { ResourceResponse } from './models'
import { Analysis } from './resources/analysis'
import { Analytics } from './resources/analytics'
import { Integrations } from './resources/integrations'
import { Rooms } from './resources/rooms'
import { SessionArchives } from './resources/session-archives'
import { SessionHighlights } from './resources/session-highlights'
import { SessionReports } from './resources/session-reports'
import { SessionStreams } from './resources/session-streams'
import { SessionTranscripts } from './resources/session-transcripts'
import { Sessions } from './resources/sessions'
import { Users } from './resources/users'

export interface JargonConfig {
  authToken?: string
  accessToken?: string
  environment?: string
  authTokenGetter?: () => Promise<string | undefined> | string | undefined
  accessTokenGetter?: () => Promise<string | undefined> | string | undefined
}

export class Jargon {
  public analysis = new Analysis(this)
  public analytics = new Analytics(this)
  public integrations = new Integrations(this)
  public requestor: Axios.AxiosInstance
  public rooms = new Rooms(this)
  public sessionArchives = new SessionArchives(this)
  public sessionHighlights = new SessionHighlights(this)
  public sessionReports = new SessionReports(this)
  public sessions = new Sessions(this)
  public sessionStreams = new SessionStreams(this)
  public sessionTranscripts = new SessionTranscripts(this)
  public users = new Users(this)

  public accessToken?: string
  public authToken?: string
  public environment: string

  constructor(config: JargonConfig = {}) {
    this.accessToken = config.accessToken
    this.authToken = config.authToken
    this.environment = config.environment || process.env.NODE_ENV || 'development'

    if (!!config.authTokenGetter && typeof config.authTokenGetter === 'function') {
      this.authTokenGetter = config.authTokenGetter
    }

    if (!!config.accessTokenGetter && typeof config.authTokenGetter === 'function') {
      this.accessTokenGetter = config.accessTokenGetter
    }

    this.requestor = Axios.default.create({
      baseURL: this.environment === 'production' ? 'https://api.jargon.ai/v1/' : 'https://api-staging.jargon.ai/v1/',
    })

    this.requestor.interceptors.request.use(this.requestInterceptor.bind(this))
    this.requestor.interceptors.response.use(this.responseInterceptor.bind(this))
  }

  public authTokenGetter(): Promise<string | undefined> | string | undefined {
    return this.authToken
  }

  public accessTokenGetter(): Promise<string | undefined> | string | undefined {
    return this.accessToken
  }

  public request(params: Axios.AxiosRequestConfig): ResourceResponse<any> {
    return Bluebird.resolve(this.requestor.request(params))
  }

  private async requestInterceptor(config: Axios.AxiosRequestConfig) {
    const [ authToken, accessToken ] = await Promise.all([this.authTokenGetter(), this.accessTokenGetter()])

    if (!!authToken) {
      config.headers.Authorization = `Bearer ${authToken}`
    }

    if (!!accessToken) {
      config.headers.AccessToken = accessToken
    }

    return config
  }

  private responseInterceptor(response: Axios.AxiosResponse) {
    // TODO: better error handling
    // TODO: token expiration handling

    return response.data
  }

  set baseURL(url: string) {
    this.requestor.defaults.baseURL = url
  }

  get baseURL() {
    return this.requestor.defaults.baseURL
  }

}