public protocol RefreshableAuthentication {
  var isRefreshNeeded: Bool { get }
  var accessToken: String { get }
  func refresh() -> Single<Self>

  static func find() -> Self?
}

import RxSwift
import Moya
import RxMoyaAuthenticatable

struct SpotifyAuthentication: RefreshableAuthentication, Decodable {

  let accessToken: String
  var refreshToken: String!
  var createdAt: Date = Date()
  let expiresIn: Int

  var isRefreshNeeded: Bool {
    let threshold = TimeInterval(self.expiresIn / 2)
    let result = self.expiresAt < Date().addingTimeInterval(threshold)
    return result
  }

  static func find() -> SpotifyAuthentication? {
    return SpotifyAuthenticationStore.find()
  }

  func refresh() -> Single<SpotifyAuthentication> {
    let refreshToken = self.refreshToken
    return
      SpotifyAuthAPI
        .sharedProvider
        .rx
        .request(.refreshToken(refreshToken: self.refreshToken))
        .map { response -> SpotifyAuthentication in
          if var authentication = try? JSONDecoder().decode(SpotifyAuthentication.self, from: response.data) {
            authentication.refreshToken = refreshToken
            return authentication
          } else {
            throw SpotifyAPIError.mappingError
          }
        }.do(
          onSuccess: { authentication in
            SpotifyAuthenticationStore.save(authentication: authentication)
          },
          onError: { error in
            print(error)
          }
        )
  }
}

extension SpotifyAuthentication {

  enum CodingKeys: String, CodingKey {
    case accessToken = "access_token"
    case refreshToken = "refresh_token"
    case expiresIn = "expires_in"
  }

  var expiresAt: Date {
    return createdAt.addingTimeInterval(TimeInterval(expiresIn))
  }
}

let provider = MoyaProvider<SpotifyAPI>(
  requestClosure: RxMoyaAuthenticatable<SpotifyAPI, SpotifyAuthentication>().requestClosure
)