package com.cygnus.client;

import com.cygnus.client.model.CloudIdentitySession;
import com.cygnus.client.model.CloudQueryResponse;
import com.cygnus.client.model.LoginPayload;
import com.cygnus.client.security.LoginEnvelopeEncryptor;
import com.cygnus.client.security.MachineTokenProvider;
import java.time.Clock;
import java.util.UUID;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

public class CloudIdentityClient {

    private final WebClient webClient;
    private final MachineTokenProvider tokenProvider;
    private final LoginEnvelopeEncryptor encryptor;
    private final CloudClientProperties properties;
    private final Clock clock;

    public CloudIdentityClient(
            WebClient webClient,
            MachineTokenProvider tokenProvider,
            LoginEnvelopeEncryptor encryptor,
            CloudClientProperties properties,
            Clock clock) {
        this.webClient = webClient;
        this.tokenProvider = tokenProvider;
        this.encryptor = encryptor;
        this.properties = properties;
        this.clock = clock;
    }

    public Mono<CloudIdentitySession> authenticate(String loginId, String password) {
        LoginPayload payload = new LoginPayload(
                loginId,
                password,
                properties.clientId(),
                properties.installationId(),
                UUID.randomUUID().toString(),
                clock.instant());
        return tokenProvider.accessToken()
                .flatMap(token -> webClient.post()
                        .uri(properties.baseUri().resolve("/api/v1/identity/login"))
                        .header(HttpHeaders.AUTHORIZATION, "Bearer " + token)
                        .contentType(MediaType.APPLICATION_JSON)
                        .bodyValue(encryptor.encrypt(payload))
                        .retrieve()
                        .bodyToMono(CloudIdentitySession.class))
                .timeout(properties.requestTimeout());
    }

    public Mono<CloudQueryResponse> fetchQuery(int queryId) {
        return tokenProvider.accessToken()
                .flatMap(token -> webClient.get()
                        .uri(properties.baseUri().resolve("/api/v1/queries/" + queryId))
                        .header(HttpHeaders.AUTHORIZATION, "Bearer " + token)
                        .accept(MediaType.APPLICATION_JSON)
                        .retrieve()
                        .bodyToMono(CloudQueryResponse.class))
                .timeout(properties.requestTimeout());
    }

    public Mono<CloudQueryResponse> fetchQuery(String queryKey) {
        return tokenProvider.accessToken()
                .flatMap(token -> webClient.get()
                        .uri(properties.baseUri().resolve("/api/v1/queries/key/" + queryKey))
                        .header(HttpHeaders.AUTHORIZATION, "Bearer " + token)
                        .accept(MediaType.APPLICATION_JSON)
                        .retrieve()
                        .bodyToMono(CloudQueryResponse.class))
                .timeout(properties.requestTimeout());
    }
}