import SwiftyVK

class VKDelegateExample: SwiftyVKDelegate {

    func vkNeedsScopes(for sessionId: String) -> Scopes {
      // Called when SwiftyVK attempts to get access to user account
      // Should return a set of permission scopes
    }

    func vkNeedToPresent(viewController: VKViewController) {
      // Called when SwiftyVK wants to present UI (e.g. webView or captcha)
      // Should display given view controller from current top view controller
    }

    func vkTokenCreated(for sessionId: String, info: [String : String]) {
      // Called when user grants access and SwiftyVK gets new session token
      // Can be used to run SwiftyVK requests and save session data
    }

    func vkTokenUpdated(for sessionId: String, info: [String : String]) {
      // Called when existing session token has expired and successfully refreshed
      // You don't need to do anything special here
    }

    func vkTokenRemoved(for sessionId: String) {
      // Called when user was logged out
      // Use this method to cancel all SwiftyVK requests and remove session data
    }
}

VK.setUp(appId: String, delegate: SwiftyVKDelegate)

VK.release()

VK.sessions.default.logIn(
      onSuccess: { _ in
        // Start working with SwiftyVK session here
      },
      onError: { _ in
        // Handle an error if something went wrong
      }
  )

func application(
   _ application: UIApplication,
   open url: URL,
   sourceApplication: String?,
   annotation: Any
   ) -> Bool {
   VK.handle(url: url, sourceApplication: sourceApplication)
   return true
}

func application(
    _ app: UIApplication,
    open url: URL,
    options: [UIApplicationOpenURLOptionsKey : Any] = [:]
    ) -> Bool {
    let app = options[.sourceApplication] as? String
    VK.handle(url: url, sourceApplication: app)
    return true
}

VK.sessions.default.logIn(rawToken: String, expires: TimeInterval)

// Start working with SwiftyVK session here

VK.API.Users.get(.empty)
    .onSuccess { /* handle and parse response */ }
    .onError { /* handle error */ }
    .send()

VK.API.Users.get(.empty)

VK.API.Users.get([
    .userId: "1",
    .fields: "sex,bdate,city"
    ])

VK.API.Users.get(.empty)
    .onSuccess {
        let response = try JSONSerialization.jsonObject(with: $0)
    }

VK.API.Users.get(.empty)
    .onError {
        print("Request failed with error: ($0)")
     }

// `send()` function returns `Task` object which has `cancel()` function
let request = VK.API.Users.get([
    .userId: "1",
    .fields: "sex,bdate,city"
    ])
    .onSuccess { print($0) }
    .send()

// Cancel sheduled request.
// onSuccess callback will never be executed.
request.cancel()

VK.API.Users.get(.empty)
    .chain { response in
        // This block will be called only
        // when `users.get` method is successfully executed.
        // Receives result of executing `users.get` method.
        let user = try JSONDecoder().decode(User.self, from: response)
        return VK.API.Messages.send([
            .userId: user.id,
            .message: "Hello"
        ])
    }
    .onSuccess { response in
        // This block will be called only when both `users.get` and `messages.send`
        // methods are successfully executed.
        // `response` is a result of `messages.send` method
    }
    .onError { error in
        // This block will be called when either `users.get` or `messages.send` methods is failed.
        // Receives error of executing `users.get` or `messages.send` method.
    }
    .send()

// Set different httpMethod only for this request
VK.API.Users.get(.empty)
    .configure(with: Config(httpMethod: .POST))

// Set default apiVersion value for all requests in default session
VK.sessions.default.config.apiVersion = "5.68"

// Get path to image file
guard let path = Bundle.main.path(forResource: "testImage", ofType: "jpg") else { return }

// Get data from image file by path
guard let data = try Data(contentsOf: URL(fileURLWithPath: path)) else { return }

// Create SwiftyVK Media representation from given data
let media = Media.image(data: data, type: .jpg)

// Upload image to server
VK.API.Upload.Photo.toWall(media, to: .user(id: "4680178"))
    .onSuccess { print($0) }
    .onError { print($0) }
    .onProgress {
        // This callback available only for uploading requests
        // Use it to handle uploading status and show it to user
        
        switch $0 {
            case let .sent(current, of):
                print("sent", current, "of": of)
            case let .recieve(current, of):
                print("recieve", current, "of": of)
        }
    } 
    .send()

VK.sessions.default.longPoll.start {
    // This callback will be executed each time
    // long poll client receives a set of new events
    print($0)
}

VK.sessions.default.longPoll.start {
    for event in $0 {
        switch event {
            case let .type1(data):
                let json = JSON(data)
                print(json)
            default:
                break
        }
    }
}

VK.sessions.default.longPoll.stop()

VK.sessions.default.share(
    ShareContext(
        text: "This post made with #SwiftyVK 🖖🏽",
        images: [
            ShareImage(data: data, type: .jpg), // JPG image representation
        ],
        link: ShareLink(
            title: "Follow the white rabbit", // Link description
            url: link // URL to site
        )
    ),
    onSuccess: { /* Handle response */ },
    onError: { /* Handle error */ }