/*-
 * #%L
 * Smile CDR - CDR
 * %%
 * Copyright (C) 2016 - 2026 Smile CDR, Inc.
 * %%
 * All rights reserved.
 * #L%
 */
package ca.cdr.test.app.clients;

import ca.cdr.test.app.clients.common.HttpClientOwnership;
import ca.cdr.test.app.clients.common.RequestFactoryUtil;
import ca.cdr.test.app.clients.common.SmileTestHttpClient;
import ca.uhn.fhir.jpa.packages.NpmPackageAssetInfoListJson;
import ca.uhn.fhir.jpa.packages.NpmPackageMetadataJson;
import ca.uhn.fhir.jpa.packages.NpmPackageSearchResultJson;
import ca.uhn.fhir.jpa.packages.PackageDeleteOutcomeJson;
import ca.uhn.fhir.jpa.packages.PackageInstallOutcomeJson;
import ca.uhn.fhir.jpa.packages.PackageInstallationSpec;
import ca.uhn.fhir.jpa.packages.PackageInstallationStatusJson;
import jakarta.annotation.Nonnull;
import jakarta.annotation.Nullable;
import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.client.support.BasicAuthenticationInterceptor;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestClient;
import org.springframework.web.util.UriComponentsBuilder;

import java.util.Objects;

/**
 * NpmPackageClient is a client for the NPM Package Registry API of the CDR.
 * It currently supports anonymous and http-basic authentication.
 * 
 * This client provides access to package installation operations through
 * Smile CDR's package registry endpoint, typically running on port 8002.
 */
public class NpmPackageClient implements AutoCloseable {
        private static final Logger ourLog = LoggerFactory.getLogger(NpmPackageClient.class);

        private final RestClient myRestClient;

        /**
         * The client this one issues on, and whether closing this client should release it.
         * {@literal null} for a client built from a {@link RestClient} directly, which brought no
         * connection pool of its own.
         */
        private final HttpClientOwnership myOwnership;

        NpmPackageClient(RestClient theRestClient) {
                this(theRestClient, null);
        }

        private NpmPackageClient(RestClient theRestClient, @Nullable HttpClientOwnership theOwnership) {
                myRestClient = theRestClient;
                myOwnership = theOwnership;
        }

        /**
         * Build an NpmPackageClient with authentication
         * @param theBaseUrl The base URL of the package registry
         * @param theUsername Username for authentication
         * @param thePassword Password for authentication
         * @return Configured NpmPackageClient
         */
        /**
         * Opens a client authenticating as the given user, over a connection pool of its own.
         * <p>
         * The caller owns the pool: open this in a try-with-resources block, or close it from an
         * {@code @AfterAll} when it is a field. Use
         * {@link #issuingOn(SmileTestHttpClient, String, String, String)} instead where a client to
         * issue on already exists.
         *
         * @param theBaseUrl the base URL of the package registry
         * @param theUsername the user to authenticate as
         * @param thePassword that user's password
         */
        public static @Nonnull NpmPackageClient open(
                        @Nonnull String theBaseUrl, @Nonnull String theUsername, @Nonnull String thePassword) {
                return authenticatedClient(HttpClientOwnership.resolve(null), theBaseUrl, theUsername, thePassword);
        }

        /**
         * Opens a client sending no credentials, over a connection pool of its own.
         * <p>
         * The caller owns the pool ? see {@link #open(String, String, String)}.
         *
         * @param theBaseUrl the base URL of the package registry
         */
        public static @Nonnull NpmPackageClient openAnonymous(@Nonnull String theBaseUrl) {
                HttpClientOwnership ownership = HttpClientOwnership.resolve(null);

                return new NpmPackageClient(
                        builderForUrlWithJsonDefault(theBaseUrl, ownership.client()).build(), ownership);
        }

        /**
         * Builds a client that issues its requests on {@code theHttpClient}, sharing that client's
         * connection pool and cookie store with everything else built over it.
         * <p>
         * The pool stays the caller's: {@link #close()} leaves it open, so there is nothing here for the
         * caller to release. Use {@link #open(String, String, String)} to build a pool of your own.
         *
         * @param theHttpClient the client to issue on, which the caller keeps ownership of
         * @param theBaseUrl the base URL of the package registry
         * @param theUsername the user to authenticate as
         * @param thePassword that user's password
         * @see ca.cdr.test.app.clients.common.RequestFactoryUtil#wrap(SmileTestHttpClient)
         */
        public static @Nonnull NpmPackageClient issuingOn(
                        @Nonnull SmileTestHttpClient theHttpClient,
                        @Nonnull String theBaseUrl,
                        @Nonnull String theUsername,
                        @Nonnull String thePassword) {
                return authenticatedClient(
                        HttpClientOwnership.resolve(theHttpClient), theBaseUrl, theUsername, thePassword);
        }

        private static @Nonnull NpmPackageClient authenticatedClient(
                        @Nonnull HttpClientOwnership theOwnership,
                        @Nonnull String theBaseUrl,
                        @Nonnull String theUsername,
                        @Nonnull String thePassword) {
                RestClient restClient = builderForUrlWithJsonDefault(theBaseUrl, theOwnership.client())
                        .requestInterceptor(new BasicAuthenticationInterceptor(theUsername, thePassword))
                        .build();

                return new NpmPackageClient(restClient, theOwnership);
        }

        /**
         * @deprecated Use {@link #open(String, String, String)}, whose name says that the client owns the
         *    connection pool it returns and that the caller has to close it.
         */
        @Deprecated(since = "2026.11.R01", forRemoval = true)
        public static @Nonnull NpmPackageClient build(
                        @Nonnull String theBaseUrl, @Nonnull String theUsername, @Nonnull String thePassword) {
                return open(theBaseUrl, theUsername, thePassword);
        }

        /**
         * @deprecated Use {@link #openAnonymous(String)}, whose name says that the client owns the
         *    connection pool it returns and that the caller has to close it.
         */
        @Deprecated(since = "2026.11.R01", forRemoval = true)
        public static @Nonnull NpmPackageClient buildAnonymous(@Nonnull String theBaseUrl) {
                return openAnonymous(theBaseUrl);
        }

        /**
         * Install a package using the provided specification
         * @param theSpec The package installation specification
         * @return The installation outcome
         */
        @Nonnull
        public PackageInstallOutcomeJson installPackageBySpec(PackageInstallationSpec theSpec) {
                Validate.notNull(theSpec, "Package specification is required");
                Validate.notEmpty(theSpec.getName(), "Package name is required");
                Validate.notEmpty(theSpec.getVersion(), "Package version is required");
                
                ourLog.info("Installing package {}#{}", theSpec.getName(), theSpec.getVersion());
                
                PackageInstallOutcomeJson result = myRestClient
                        .put()
                        .uri("/write/install/by-spec")
                        .body(theSpec)
                        .contentType(MediaType.APPLICATION_JSON)
                        .retrieve()
                        .body(PackageInstallOutcomeJson.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Install a package using the provided specification as a JSON string
         * @param theSpecJson The package installation specification as JSON string
         * @return The installation outcome
         */
        @Nonnull
        public PackageInstallOutcomeJson installPackageBySpec(String theSpecJson) {
                Validate.notEmpty(theSpecJson, "Package specification JSON is required");
                
                ourLog.info("Installing package from JSON specification: {}", theSpecJson);
                
                PackageInstallOutcomeJson result = myRestClient
                        .put()
                        .uri("/write/install/by-spec")
                        .contentType(MediaType.APPLICATION_JSON)
                        .body(theSpecJson)
                        .retrieve()
                        .body(PackageInstallOutcomeJson.class);
                return Objects.requireNonNull(result);
        }

        @Nonnull
        public String installPackageBySpecAsync(@Nonnull PackageInstallationSpec theSpec) {
                Validate.notNull(theSpec, "Package specification is required");

                ResponseEntity<Void> response = myRestClient
                        .put()
                        .uri("/write/install/by-spec")
                        .header("Prefer", "respond-async")
                        .contentType(MediaType.APPLICATION_JSON)
                        .body(theSpec)
                        .retrieve()
                        .toBodilessEntity();
                Validate.isTrue(
                        response.getStatusCode().isSameCodeAs(HttpStatus.ACCEPTED),
                        "Expected 202 Accepted for an async install but got %s",
                        response.getStatusCode());
                String pollLocation = Validate.notEmpty(
                                response.getHeaders().getFirst(HttpHeaders.CONTENT_LOCATION),
                                "Async install response had no Content-Location");
                String jobId = UriComponentsBuilder.fromUriString(pollLocation).build().getQueryParams().getFirst("_jobId");
                return Validate.notEmpty(jobId, "Content-Location %s had no _jobId", pollLocation);
        }

        @Nonnull
        public PackageInstallationStatusJson getInstallationStatus(String theJobId) {
                Validate.notEmpty(theJobId, "Job ID is required");

                PackageInstallationStatusJson result = myRestClient
                        .get()
                        .uri("/write/install/status?_jobId={jobId}", theJobId)
                        .retrieve()
                        .body(PackageInstallationStatusJson.class);
                return Objects.requireNonNull(result);
        }

        @Nonnull
        public PackageInstallOutcomeJson installPackageByParam(
                        String theName,
                        String theVersion,
                        boolean theFetchDependencies,
                        @Nonnull PackageInstallationSpec.InstallModeEnum theInstallMode,
                        @Nonnull PackageInstallationSpec.VersionPolicyEnum theVersionPolicy) {
                Validate.notEmpty(theName, "Package name is required");
                Validate.notEmpty(theVersion, "Package version is required");

                PackageInstallOutcomeJson result = myRestClient
                        .put()
                        .uri(builder -> builder.path("/write/install/by-param")
                                .queryParam("name", theName)
                                .queryParam("version", theVersion)
                                .queryParam("fetchDependencies", theFetchDependencies)
                                .queryParam("installMode", theInstallMode)
                                .queryParam("versionPolicy", theVersionPolicy)
                                .build())
                        .retrieve()
                        .body(PackageInstallOutcomeJson.class);
                return Objects.requireNonNull(result);
        }

        @Nonnull
        public PackageDeleteOutcomeJson deletePackage(String theName, String theVersion) {
                Validate.notEmpty(theName, "Package name is required");
                Validate.notEmpty(theVersion, "Package version is required");

                PackageDeleteOutcomeJson result = myRestClient
                        .delete()
                        .uri("/write/{name}/{version}", theName, theVersion)
                        .retrieve()
                        .body(PackageDeleteOutcomeJson.class);
                return Objects.requireNonNull(result);
        }

        @Nonnull
        public NpmPackageSearchResultJson searchPackages(@Nonnull MultiValueMap<String, String> theQueryParams) {
                NpmPackageSearchResultJson result = myRestClient
                        .get()
                        .uri(builder -> builder.path("/npm/-/v1/search").queryParams(theQueryParams).build())
                        .retrieve()
                        .body(NpmPackageSearchResultJson.class);
                return Objects.requireNonNull(result);
        }

        @Nonnull
        public NpmPackageMetadataJson getPackageMetadata(String theName) {
                Validate.notEmpty(theName, "Package name is required");

                NpmPackageMetadataJson result = myRestClient
                        .get()
                        .uri("/npm/{name}", theName)
                        .retrieve()
                        .body(NpmPackageMetadataJson.class);
                return Objects.requireNonNull(result);
        }

        @Nonnull
        public NpmPackageAssetInfoListJson findPackageAssetInfoByUrl(String theFhirVersion, String theCanonicalUrl) {
                Validate.notEmpty(theFhirVersion, "FHIR version is required");
                Validate.notEmpty(theCanonicalUrl, "Canonical URL is required");

                NpmPackageAssetInfoListJson result = myRestClient
                        .get()
                        .uri(builder -> builder.path("/npm/-/v1/findPackageAssetInfoByUrl")
                                .queryParam("_fhirVersion", theFhirVersion)
                                .queryParam("_canonicalUrl", theCanonicalUrl)
                                .build())
                        .retrieve()
                        .body(NpmPackageAssetInfoListJson.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Create a RestClient builder configured for JSON communication
         * @param theBaseUrl The base URL
         * @return Configured RestClient builder
         */
        private static @Nonnull RestClient.Builder builderForUrlWithJsonDefault(
                        String theBaseUrl, @Nonnull SmileTestHttpClient theHttpClient) {
                HttpComponentsClientHttpRequestFactory requestFactory = RequestFactoryUtil.wrap(theHttpClient);

                return RestClient.builder()
                        .baseUrl(theBaseUrl)
                        .requestFactory(requestFactory)
                        // This sets the default content type to JSON, but allows the actual request to override it.
                        .defaultRequest(r -> r.accept(MediaType.APPLICATION_JSON));
        }

        /**
         * Releases the connection pool this client built for itself. A no-op when the client was built
         * over one supplied by a caller, which owns its own pool.
         */
        @Override
        public void close() {
                if (myOwnership != null) {
                        myOwnership.closeIfOwned();
                }
        }
}