//
//  NetworkService.swift
//  PKBPartyKit
//
//  Created by alfian0 on 2/6/18.
//  Copyright © 2018 Extra Integer. All rights reserved.
//

import ObjectMapper
import Moya
import RxSwift

enum BaseResponse {
    case success(data: Mappable?)
    case error(error: ErrorResponse?)
}

struct NetworkService: INetworkService {

    static let instance = NetworkService()
    fileprivate let disposeBag = DisposeBag()
    fileprivate let provider: MoyaProvider<NetworkAPI>

    private init() {
        self.provider = MoyaProvider<NetworkAPI>(
            plugins: [
                RequestLoadingPlugin()
            ]
        )
    }
}

extension NetworkService {

    internal func requestObject(_ token: NetworkAPI, mappableClass: Mappable.Type? = nil) -> Observable<BaseResponse?> {

        return Observable.create({ (observer) -> Disposable in
            return self.provider.rx.request(token)
                .filterSuccessfulStatusCodes()
                .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background))
                .subscribe { event in
                    switch event {
                    case .success(let response):

                        // Check mappableClass is not nil
                        // mappableClass is model
                        guard let mappableClass = mappableClass else {
                            observer.onNext(nil)
                            observer.onCompleted()
                            return
                        }

                        do {
                            // First we need map response to JSON
                            // Parse json to get success status
                            // If we are not getting success status throw NetworkError.IncorrectDataReturned
                            guard let jsonResponse = try response.mapJSON() as? [String: Any] else {
                                observer.onError(NetworkError.IncorrectDataReturned)
                                return
                            }

                            // Map jsonData to ObjectMapper format
                            let map = Map(mappingType: .fromJSON, JSON: jsonResponse)

                            if let statusCode = response.response?.statusCode, (statusCode >= 200 && statusCode < 300) {
                                guard let modelObject = mappableClass.init(map: map) else {
                                    observer.onError(NetworkError.IncorrectDataReturned)
                                    return
                                }
                                observer.onNext(.success(data: modelObject))
                                observer.onCompleted()
                            } else {
                                guard let errorResponse = ErrorResponse.init(map: map) else {
                                    observer.onError(NetworkError.IncorrectDataReturned)
                                    return
                                }
                                observer.onNext(.error(error: errorResponse))
                                observer.onCompleted()
                            }
                        } catch {
                            observer.onError(NetworkError.IncorrectDataReturned)
                        }
                        break
                    case .error(let error):
                        if let error = error as? MoyaError {
                            do {
                                guard let json = try error.response?.mapJSON() as? [String: Any] else {
                                    observer.onError(NetworkError.IncorrectDataReturned)
                                    return
                                }
                                let map = Map(mappingType: .fromJSON, JSON: json)
                                guard let errorResponse = ErrorResponse.init(map: map) else {
                                    observer.onError(NetworkError.IncorrectDataReturned)
                                    return
                                }
                                observer.onNext(.error(error: errorResponse))
                            } catch {
                                observer.onError(NetworkError(error: error as NSError))
                            }
                        } else {
                            observer.onError(NetworkError(error: error as NSError))
                        }
                    }
            }
        })
    }
}