import Foundation
import Apollo

extension Result {
    var value: Success? { do { return try get() } catch { return nil } }
    var error: Failure? { do { _ = try get();return nil } catch { return error as? Failure } }
}

extension Network.Service {
    class GraphQL: Common.Service.Provider {
        #warning("shared should be removed or init make private")
        static let shared = GraphQL()
        private var _client: ApolloClient!
        private var _paycashClient: ApolloClient!
        init() { }
    }
}

extension Network.Service.GraphQL {
    @discardableResult
    func fetch<Query: GraphQLQuery>(query: Query, completion: @escaping (Result<Query.Data, Error>) -> Void ) -> Cancellable {
        client.fetch(query: query, cachePolicy: .fetchIgnoringCacheCompletely) {
            if let data = $0.value?.data {
                completion(.success(data))
            } else if let error = $0.error {
                completion(.failure(error))
            } else {
                completion(.failure(NSError.error(L10n.Common.Alert.error)))
            }
        }
    }
    @discardableResult
    func fetchV2<Query: GraphQLQuery>(query: Query, completion: @escaping (Result<Query.Data, Error>) -> Void ) -> Cancellable {
        paycashClient.fetch(query: query, cachePolicy: .fetchIgnoringCacheCompletely) {
            if let data = $0.value?.data {
                completion(.success(data))
            } else if let error = $0.error {
                completion(.failure(error))
            } else {
                completion(.failure(NSError.error(L10n.Common.Alert.error)))
            }
        }
    }
    @discardableResult
    func perform<Mutation: GraphQLMutation>(mutation: Mutation, completion: ((Result<Mutation.Data, Error>) -> Void)? = nil) -> Cancellable {
        client.perform(mutation: mutation) {
            guard let completion = completion else { return }
            if let data = $0.value?.data {
                completion(.success(data))
            } else if let error = $0.error {
                completion(.failure(error))
            } else {
                completion(.failure(NSError.error(L10n.Common.Alert.error)))
            }
        }
    }
}

extension Network.Service.GraphQL {
    fileprivate var client: ApolloClient {
        if !_client.isExist,
           let url = URL(string: ApplicationEnvironment.shared().current.other.listGraphQL) {
            _client = ApolloClient(url: url)
        }
        return _client
    }
    
    fileprivate var paycashClient: ApolloClient {
        let environment = ApplicationEnvironment.shared().current
        if !_paycashClient.isExist,
           let url = URL(string: environment.backend.urlPath) {
            
            let store = ApolloStore(cache: InMemoryNormalizedCache())
            let provider = DefaultInterceptorProvider(store: store)
            let transport = RequestChainNetworkTransport(interceptorProvider: provider,
                                                         endpointURL: url,
                                                         additionalHeaders: environment.headers)
            _paycashClient = ApolloClient(networkTransport: transport, store: store)
        }
        return _paycashClient
    }
}