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

import ca.cdr.api.model.json.OAuth2ClientDetailsJson;
import ca.cdr.api.model.json.OAuth2WritableClientDetailsJson;
import ca.cdr.api.model.json.TransactionLogEventsJson;
import ca.cdr.api.model.json.UserDetailsJson;
import ca.cdr.test.model.NodeConfigurations;
import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.context.FhirVersionEnum;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.annotation.Nonnull;
import jakarta.annotation.Nullable;
import org.apache.commons.lang3.Validate;
import org.apache.hc.client5.http.config.ConnectionConfig;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.cookie.BasicCookieStore;
import org.apache.hc.client5.http.impl.classic.HttpClientBuilder;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.client5.http.socket.ConnectionSocketFactory;
import org.apache.hc.client5.http.socket.PlainConnectionSocketFactory;
import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory;
import org.apache.hc.core5.http.URIScheme;
import org.apache.hc.core5.http.config.Registry;
import org.apache.hc.core5.http.config.RegistryBuilder;
import org.apache.hc.core5.pool.PoolConcurrencyPolicy;
import org.apache.hc.core5.pool.PoolReusePolicy;
import org.apache.hc.core5.util.TimeValue;
import org.hl7.fhir.instance.model.api.IBaseParameters;
import org.hl7.fhir.instance.model.api.IBaseResource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.MediaType;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.client.support.BasicAuthenticationInterceptor;
import org.springframework.http.converter.ByteArrayHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.ResourceHttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestClient;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.TimeUnit;

import static org.testcontainers.shaded.org.awaitility.Awaitility.await;

// Many new methods generated by Claude Sonnet 3.7

/**
 * AdminJsonRestClient is a client for the Admin API of the CDR.
 * It currently supports anonymous and http-basic authentication.
 */
public class AdminJsonRestClient {
        private static final Logger ourLog = LoggerFactory.getLogger(AdminJsonRestClient.class);

        final RestClient myRestClient;

        AdminJsonRestClient(RestClient theRestClient) {
                myRestClient = theRestClient;
        }

        public static AdminJsonRestClient build(String theBaseUrl, String theUsername, String thePassword) {
                RestClient restClient = builderForUrlWithJsonDefault(theBaseUrl)
                        .requestInterceptor(new BasicAuthenticationInterceptor(theUsername, thePassword))
                        .build();

                return new AdminJsonRestClient(restClient);
        }

        public static AdminJsonRestClient buildAnonymous(String theBaseUrl) {
                RestClient restClient = builderForUrlWithJsonDefault(theBaseUrl).build();

                return new AdminJsonRestClient(restClient);
        }

        private static @Nonnull RestClient.Builder builderForUrlWithJsonDefault(String theBaseUrl) {
                HttpComponentsClientHttpRequestFactory requestFactory = buildSmileRequestFactory();

                List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
                messageConverters.add(new ByteArrayHttpMessageConverter());
                messageConverters.add(new StringHttpMessageConverter());
                messageConverters.add(new ResourceHttpMessageConverter(false));
                messageConverters.add(new AllEncompassingFormHttpMessageConverter());
                messageConverters.add(new MappingJackson2HttpMessageConverter());

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

        /**
         * Set a massive timeout
         * Disable Redirects.
         * Set up local cookie storage.
         */
        private static @Nonnull HttpComponentsClientHttpRequestFactory buildSmileRequestFactory() {
                Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                        .register(URIScheme.HTTP.id, PlainConnectionSocketFactory.getSocketFactory())
                        .register(URIScheme.HTTPS.id, SSLConnectionSocketFactory.getSocketFactory())
                        .build();

                TimeValue ttl = TimeValue.of(5000, TimeUnit.MILLISECONDS);

                ConnectionConfig connectionConfig = ConnectionConfig.custom()
                        .setConnectTimeout(600000, TimeUnit.MILLISECONDS)
                        .setSocketTimeout(600000, TimeUnit.MILLISECONDS)
                        .build();

                PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(
                        socketFactoryRegistry, PoolConcurrencyPolicy.LAX, PoolReusePolicy.LIFO, ttl);
                connectionManager.setMaxTotal(99);
                connectionManager.setDefaultMaxPerRoute(99);
                connectionManager.setDefaultConnectionConfig(connectionConfig);

                HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
                BasicCookieStore cookieStore = new BasicCookieStore();
                httpClientBuilder.setDefaultCookieStore(cookieStore);
                httpClientBuilder.disableRedirectHandling();
                httpClientBuilder.setConnectionManager(connectionManager);

                RequestConfig requestConfig = RequestConfig.custom()
                        .setConnectionRequestTimeout(600000, TimeUnit.MILLISECONDS)
                        .build();
                httpClientBuilder.setDefaultRequestConfig(requestConfig);

                HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClientBuilder.build());
                return requestFactory;
        }


        @Nonnull
        public UserDetailsJson userCreate(String theNode, String theModuleId, UserDetailsJson userDetails) {
                Validate.notEmpty(theNode, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notNull(userDetails, "User does not have an assigned pid.  Use userCreate() to create users.");
                UserDetailsJson result = myRestClient
                        .post()
                        .uri("user-management/{nodeId}/{moduleId}", theNode, theModuleId)
                        .body(userDetails)
                        .retrieve()
                        .body(UserDetailsJson.class);
                return Objects.requireNonNull(result);
        }

        @Nonnull
        public UserDetailsJson userUpdate(UserDetailsJson theUserDetails) {
                Validate.notEmpty(theUserDetails.getNodeId(), "Node ID is required");
                Validate.notEmpty(theUserDetails.getModuleId(), "Module ID is required");
                Validate.notNull(
                        theUserDetails.getPid(), "User does not have an assigned pid.  Use userCreate() to create users.");
                UserDetailsJson result = myRestClient
                        .put()
                        .uri(
                                "user-management/{nodeId}/{moduleId}/{userId}",
                                theUserDetails.getNodeId(),
                                theUserDetails.getModuleId(),
                                theUserDetails.getPid())
                        .body(theUserDetails)
                        .retrieve()
                        .body(UserDetailsJson.class);
                return Objects.requireNonNull(result);
        }

        @Nonnull
        public JsonNode userFindByUsername(String theNodeId, String theModuleId, String theUsername) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notEmpty(theUsername, "username is required");
                JsonNode result = myRestClient
                        .get()
                        .uri("user-management/{nodeId}/{moduleId}?searchTerm={username}", theNodeId, theModuleId, theUsername)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Find users by username and return the result as a String that can be used with ObjectMapper
         *
         * @param theNodeId   The node ID
         * @param theModuleId The module ID
         * @param theUsername The username to search for
         * @return The JSON string representation of the result
         */
        @Nonnull
        public String userFindByUsernameAsString(String theNodeId, String theModuleId, String theUsername) {
                JsonNode result = userFindByUsername(theNodeId, theModuleId, theUsername);
                return result.toString();
        }

        @Nonnull
        public JsonNode userFindAll(String theNodeId, String theModuleId, int thePageSize) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                JsonNode result = myRestClient
                        .get()
                        .uri("user-management/{nodeId}/{moduleId}?pageSize={pageSize}", theNodeId, theModuleId, thePageSize)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Find all users and return the result as a String that can be used with ObjectMapper
         *
         * @param theNodeId   The node ID
         * @param theModuleId The module ID
         * @param thePageSize The page size
         * @return The JSON string representation of the result
         */
        @Nonnull
        public String userFindAllAsString(String theNodeId, String theModuleId, int thePageSize) {
                JsonNode result = userFindAll(theNodeId, theModuleId, thePageSize);
                return result.toString();
        }

        @Nonnull
        public UserDetailsJson userFetchByPid(String theNodeId, String theModuleId, Long thePid) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notNull(thePid, "User does not have an assigned pid.  Use userCreate() to create users.");
                UserDetailsJson result = myRestClient
                        .get()
                        .uri("user-management/{nodeId}/{moduleId}/{userId}", theNodeId, theModuleId, thePid)
                        .retrieve()
                        .body(UserDetailsJson.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Get the module configuration for a specific node and module
         */
        @Nonnull
        public JsonNode getModuleConfig(String theNodeId, String theModuleId) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                JsonNode result = myRestClient
                        .get()
                        .uri("module-config/{nodeId}/{moduleId}", theNodeId, theModuleId)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        public JsonNode getModuleInterceptors(String theNodeId, String theModuleId) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                JsonNode result = myRestClient
                        .get()
                        .uri("module-config/{nodeId}/{moduleId}/interceptors", theNodeId, theModuleId)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Update the configuration for a specific module
         */
        @Nonnull
        public JsonNode updateModuleConfig(
                String theNodeId,
                String theModuleId,
                JsonNode theOptions,
                boolean theRestart,
                boolean theReload) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notNull(theOptions, "Options is required");

                JsonNode result =
                        myRestClient.put().uri("module-config/{nodeId}/{theModuleId}/set?restart={theRestart}&reload={theReload}", theNodeId, theModuleId, theRestart, theReload).body(theOptions).retrieve().body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Request to start a module on all processes
         */
        @Nonnull
        private JsonNode startModule(String theNodeId, String theModuleId) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                JsonNode result = myRestClient
                        .post()
                        .uri("module-config/{nodeId}/{moduleId}/start", theNodeId, theModuleId)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Request to stop a module on all processes
         * ModuleProcessesStatusChangeResponseJson
         */
        @Nonnull
        public JsonNode stopModule(String theNodeId, String theModuleId) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                JsonNode result = myRestClient
                        .post()
                        .uri("module-config/{nodeId}/{moduleId}/stop", theNodeId, theModuleId)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Request to restart a module on all processes
         */
        @Nonnull
        public JsonNode restartModule(String theNodeId, String theModuleId) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                JsonNode result = myRestClient
                        .post()
                        .uri("module-config/{nodeId}/{moduleId}/restart", theNodeId, theModuleId)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Get a list of restore points for a node
         */
        @Nonnull
        public JsonNode getRestorePoints(
                String theNodeId, @Nullable String theVersion, @Nullable String theFromDate, @Nullable String theToDate, int theOffset, int theCount) {
                Validate.notEmpty(theNodeId, "Node ID is required");

                JsonNode result = myRestClient.get()
                        .uri("module-config/{theNodeId}/restorePoints", builder->{
                                builder.queryParamIfPresent("version", Optional.ofNullable(theVersion));
                                builder.queryParamIfPresent("from", Optional.ofNullable(theFromDate));
                                builder.queryParamIfPresent("to", Optional.ofNullable(theToDate));
                                builder.queryParam("offset", theOffset);
                                builder.queryParam("count", theCount);
                                return builder.build(theNodeId);
                        }).retrieve().body(JsonNode.class);

                return Objects.requireNonNull(result);
        }

        /**
         * Get a specific restore point
         */
        @Nonnull
        public JsonNode getRestorePoint(String theNodeId, Long theId) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notNull(theId, "Restore point ID is required");
                JsonNode result = myRestClient
                        .get()
                        .uri("module-config/{nodeId}/restorePoints/{id}", theNodeId, theId)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Restore the system to a specific restore point
         */
        public void restoreSystem(String theNodeId, Long theRestorePointId) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notNull(theRestorePointId, "Restore point ID is required");
                myRestClient
                        .post()
                        .uri("module-config/{nodeId}/restorePoints/{id}/restore", theNodeId, theRestorePointId)
                        .retrieve()
                        .toBodilessEntity();
        }

        /**
         * Get health checks for all modules
         */
        @Nonnull
        public JsonNode getHealthChecks(boolean theOnlyRunning) {
                JsonNode result = myRestClient.get().uri("runtime-status/node-statuses/health-checks?onlyRunning={onlyRunning}", theOnlyRunning).retrieve().body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Get node statuses
         */
        @Nonnull
        public JsonNode getNodeStatuses() {
                JsonNode result = myRestClient
                        .get()
                        .uri("runtime-status/node-statuses/complete")
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Cancel a batch job
         */
        public void cancelBatchJob(String theModuleId, String theJobId) {
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notEmpty(theJobId, "Job ID is required");
                myRestClient
                        .get()
                        .uri("batch2-jobs/modules/{moduleId}/jobs/{jobId}/cancel", theModuleId, theJobId)
                        .retrieve()
                        .toBodilessEntity();
        }

        /**
         * Get all module IDs that support batch jobs
         */
        @Nonnull
        public String[] getAllBatchJobModuleIds() {
                String[] result = myRestClient
                        .get()
                        .uri("batch2-jobs/modules")
                        .retrieve()
                        .body(String[].class);
                return Objects.requireNonNull(result);
        }

        /**
         * Get a specific batch job instance by ID
         */
        @Nonnull
        public JsonNode getBatchJobInstance(String theModuleId, String theJobId) {
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notEmpty(theJobId, "Job ID is required");
                JsonNode result = myRestClient
                        .get()
                        .uri("batch2-jobs/modules/{moduleId}/jobs/{jobId}", theModuleId, theJobId)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Process a bulk ETL import file
         * @param theModuleId the id of the etl module to target
         * @param theFilename the optional filename as a hint for the import process
         * @param theContent the body of the csv file to import
         * @return a json response
         */
        public String processBulkImport(@Nonnull String theModuleId, @Nullable String theFilename, @Nonnull String theContent) {
                return processBulkImport(theModuleId, theFilename, null, theContent);
        }

        /**
         * Process a bulk ETL import file
         * @param theModuleId the id of the etl module to target
         * @param theFilename the optional filename as a hint for the import process
         * @param theUserJobType the optional job type to use for the import process
         * @param theContent the body of the csv file to import
         * @return a json response
         */
        public String processBulkImport(@Nonnull String theModuleId, @Nullable String theFilename, @Nullable String theUserJobType, @Nonnull String theContent) {
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notNull(theContent, "Content is required");

                return myRestClient
                        .post()
                        .uri("bulk-import/process-etl-file/{moduleId}", builder-> {
                                builder.queryParamIfPresent("filename", Optional.ofNullable(theFilename));
                                builder.queryParamIfPresent("userJobType", Optional.ofNullable(theUserJobType));
                                return builder.build(Map.of("moduleId", theModuleId));
                        })
                        .accept(MediaType.APPLICATION_JSON)
                        .body(theContent)
                        .retrieve()
                        .body(String.class);
        }

        /**
         * Get transaction logs
         */
        @Nonnull
        public TransactionLogEventsJson getTransactionLogs() {
                TransactionLogEventsJson result =
                        myRestClient.get().uri("transaction-log").retrieve().body(TransactionLogEventsJson.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Get a specific transaction log event with its body
         */
        @Nonnull
        public TransactionLogEventsJson.TransactionLogEventJson getTransactionLogEvent(
                Long theEventId, boolean theIncludeBody) {
                Validate.notNull(theEventId, "Event ID is required");

                TransactionLogEventsJson.TransactionLogEventJson result =
                        myRestClient.get().uri("transaction-log/event/{theEventId}?includeBody={includeBody}", theEventId, theIncludeBody).retrieve().body(TransactionLogEventsJson.TransactionLogEventJson.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Create an OAuth client for a specific module
         */
        @Nonnull
        public OAuth2ClientDetailsJson createOAuthClient(
                String theNodeId, String theModuleId, OAuth2WritableClientDetailsJson theClientDetails) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notEmpty(theClientDetails.getClientId(), "Client ID is required");
                Validate.notNull(theClientDetails, "Client details are required");

                OAuth2ClientDetailsJson result;
                try {
                        result = myRestClient
                                .post()
                                .uri("openid-connect-clients/{nodeId}/{moduleId}", theNodeId, theModuleId)
                                .body(theClientDetails)
                                .retrieve()
                                .body(OAuth2ClientDetailsJson.class);
                } catch (HttpClientErrorException e) {
                        ourLog.warn("Failed to create OIDC client, going to try update instead: " + e.toString());
                        result = myRestClient
                                .post()
                                .uri("openid-connect-clients/{nodeId}/{moduleId}/{clientId}", theNodeId, theModuleId, theClientDetails.getClientId())
                                .body(theClientDetails)
                                .retrieve()
                                .body(OAuth2ClientDetailsJson.class);
                }
                return Objects.requireNonNull(result);
        }

        /**
         * Update an OAuth client for a specific module
         */
        @Nonnull
        public OAuth2ClientDetailsJson updateOAuthClient(
                String theNodeId,
                String theModuleId,
                String theClientId,
                OAuth2WritableClientDetailsJson theClientDetails) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notEmpty(theClientId, "Client ID is required");
                Validate.notNull(theClientDetails, "Client details are required");

                OAuth2ClientDetailsJson result = myRestClient
                        .put()
                        .uri("openid-connect-clients/{nodeId}/{moduleId}/{clientId}", Map.of(
                                "nodeId", theNodeId,
                                "moduleId", theModuleId,
                                "clientId", theClientId))
                        .body(theClientDetails)
                        .retrieve()
                        .body(OAuth2ClientDetailsJson.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Delete an OAuth client
         */
        public void deleteOAuthClient(String theNodeId, String theModuleId, String theClientId) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notEmpty(theClientId, "Client ID is required");

                myRestClient
                        .delete()
                        .uri("openid-connect-clients/{nodeId}/{moduleId}/{clientId}", theNodeId, theModuleId, theClientId)
                        .retrieve()
                        .toBodilessEntity();
        }

        /**
         * Get an OAuth client
         */
        @Nonnull
        public OAuth2ClientDetailsJson getOAuthClient(String theNodeId, String theModuleId, String theClientId) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notEmpty(theClientId, "Client ID is required");

                OAuth2ClientDetailsJson result = myRestClient
                        .get()
                        .uri("openid-connect-clients/{nodeId}/{moduleId}/{clientId}", theNodeId, theModuleId, theClientId)
                        .retrieve()
                        .body(OAuth2ClientDetailsJson.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Create an OIDC server for a specific module
         */
        @Nonnull
        public JsonNode createOidcServer(String theNodeId, String theModuleId, JsonNode theServerDetails) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notNull(theServerDetails, "Server details are required");

                JsonNode result = myRestClient
                        .post()
                        .uri("openid-connect-servers/{nodeId}/{moduleId}", theNodeId, theModuleId)
                        .body(theServerDetails)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Get an OIDC server
         */
        @Nonnull
        public JsonNode getOidcServer(String theNodeId, String theModuleId, String theServerId) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notEmpty(theServerId, "Server ID is required");

                JsonNode result = myRestClient
                        .get()
                        .uri("openid-connect-servers/{nodeId}/{moduleId}/{serverId}", theNodeId, theModuleId, theServerId)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Update an OIDC server
         */
        @Nonnull
        public JsonNode updateOidcServer(
                String theNodeId, String theModuleId, String theServerId, JsonNode theServerDetails) {
                Validate.notEmpty(theNodeId, "Node ID is required");
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notEmpty(theServerId, "Server ID is required");
                Validate.notNull(theServerDetails, "Server details are required");

                JsonNode result = myRestClient
                        .put()
                        .uri("openid-connect-servers/{nodeId}/{moduleId}/{serverId}", theNodeId, theModuleId, theServerId)
                        .body(theServerDetails)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Get MDM links
         */
        @Nonnull
        public JsonNode getMdmLinks(String theModuleId) {
                Validate.notEmpty(theModuleId, "Module ID is required");

                JsonNode result = myRestClient
                        .get()
                        .uri("mdm/{moduleId}/query-links", theModuleId)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Merge MDM golden resources
         */
        @Nonnull
        public JsonNode mergeMdmGoldenResources(String theModuleId, Object theRequest) {
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notNull(theRequest, "Request is required");

                JsonNode result = myRestClient
                        .post()
                        .uri("mdm/{moduleId}/merge-golden-resources", theModuleId)
                        .body(theRequest)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Update MDM link
         */
        @Nonnull
        public JsonNode updateMdmLink(String theModuleId, Object theRequest) {
                Validate.notEmpty(theModuleId, "Module ID is required");
                Validate.notNull(theRequest, "Request is required");

                JsonNode result = myRestClient
                        .post()
                        .uri("mdm/{moduleId}/update-link", theModuleId)
                        .body(theRequest)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Get MDM duplicate golden resources
         */
        @Nonnull
        public JsonNode getMdmDuplicateGoldenResources(String theModuleId) {
                Validate.notEmpty(theModuleId, "Module ID is required");

                JsonNode result = myRestClient
                        .get()
                        .uri("mdm/{moduleId}/duplicate-golden-resources", theModuleId)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Submit an MDM operation to perform batch matching on all resources
         *
         * @param theModuleId   The module ID
         * @param theParameters The parameters for the MDM operation
         * @return The response as a String
         */
        @Nonnull
        public String submitMdmOperation(String theModuleId, IBaseParameters theParameters) {
                Validate.notEmpty(theModuleId, "Module ID is required");

                String body = toJsonString(theParameters);

                String result = myRestClient
                        .post()
                        .uri("{moduleId}/mdm-submit", theModuleId)
                        .body(body)
                        .retrieve()
                        .body(String.class);

                return result != null ? result : "";
        }

        public static String toJsonString(IBaseResource theResource) {
                FhirVersionEnum version = FhirVersionEnum.determineVersionForType(theResource.getClass());
                FhirContext ctx = FhirContext.forCached(version);
                return ctx.newJsonParser().encodeResourceToString(theResource);
        }

        /**
         * Exception thrown when a forbidden operation is attempted
         */
        public static class ForbiddenOperationException extends RuntimeException {
                public ForbiddenOperationException(String message, Throwable cause) {
                        super(message, cause);
                }
        }

        /**
         * Get the node configurations from the admin API.
         *
         * @return The node configurations
         */
        @Nonnull
        public NodeConfigurations getNodeConfigurations() {
                NodeConfigurations result = myRestClient
                        .get()
                        .uri("/module-config/")
                        .retrieve()
                        .body(NodeConfigurations.class);
                return Objects.requireNonNull(result);
        }

        /**
         * Get the port number for a specific module from the node configurations.
         *
         * @param theModuleId The ID of the module to get the port for
         * @return The port number, or the default FHIR port (8000) if not found
         */
        public int getPortFromModule(String theModuleId) {
                Validate.notEmpty(theModuleId, "Module ID is required");
                NodeConfigurations config = getNodeConfigurations();

                // Find the first node (assuming there's only one node in the container)
                if (config.getNodes().isEmpty()) {
                        throw new IllegalStateException("No nodes found in node configuration");
                } else {
                        NodeConfigurations.NodeConfiguration node = config.getNodes().get(0);

                        // Find the module with the given ID
                        return node.getModule(theModuleId)
                                .map(module -> {
                                        // Look for the port property in the module's configuration
                                        for (NodeConfigurations.ModuleConfigProperty property : module.getConfigProperties()) {
                                                if (property.getKey().equals("port")) {
                                                        try {
                                                                return Integer.parseInt(property.getValue());
                                                        } catch (NumberFormatException e) {
                                                                // If the port is not a valid integer, fail.
                                                                throw new IllegalArgumentException("Invalid port number: " + property.getValue(), e);
                                                        }
                                                }
                                        }
                                        // If no port property is found, return the default FHIR port
                                        return null;
                                })
                                .orElseThrow(() -> new IllegalArgumentException("Module with ID " + theModuleId + " not found in node configuration"));
                }

        }

        /**
         * Since many  methods currently return JsonNode, if you have a known model you would like to bind to, you can convert a json object to it using this method
         */
        public <T> T convertJsonNodeToModel(JsonNode jsonNode, Class<T> modelClass) throws JsonProcessingException {
                // This is a hack to work around many of our return types being hidden in cdr-api instead of cdr-api-public.
                // From Gary: We can't extract them cleanly yet to the fact that they often are relying on enums in clustermgr
                // or enums in api that we do not currently want to make public,
                // usually via 3 separate levels of nesting (e.g. node configurations -> module config -> ModuleTypeEnum
                // TODO: Fix these, and move them to public, updating the method types to our model classes.

                try {
                        ObjectMapper objectMapper = new ObjectMapper();
                        // Direct conversion from JsonNode to model class without string conversion
                        return objectMapper.treeToValue(jsonNode, modelClass);
                } catch (JsonProcessingException e) {
                        // Log the error with the actual JSON content for debugging
                        ourLog.error("Failed to convert JsonNode to " + modelClass.getSimpleName() +
                                ". JSON content: " + jsonNode.toString(), e);
                        throw e;
                }
        }

        public <T> JsonNode convertModelToJsonNode(T model) throws JsonProcessingException {
                try {
                        ObjectMapper objectMapper = new ObjectMapper();
                        // Direct conversion from model to JsonNode without going through string
                        return objectMapper.valueToTree(model);
                } catch (Exception e) {
                        throw new JsonProcessingException("Error converting model to JsonNode") {} ;
                }
        }


        @Nullable
        public TransactionLogEventsJson.TransactionLogEventJson getMostRecentTransactionLogEntry() {
                TransactionLogEventsJson events = myRestClient.get().uri("/transaction-log/?pageSize=1").retrieve().body(TransactionLogEventsJson.class);
                if (events == null || events.getEvents() == null || events.getEvents().isEmpty()) {
                        return null;
                } else {
                        return events.getEvents().get(0);
                }
        }

        @Nullable
        public Long getMostRecentTransactionLogEntryId() {
                TransactionLogEventsJson.TransactionLogEventJson entry = getMostRecentTransactionLogEntry();
                if (entry != null) {
                        return entry.getId();
                } else {
                        return null;
                }
        }

        public void awaitNewTransactionLogEntry(Long theMostRecentTxLogEntryId) {
                await().until(this::getMostRecentTransactionLogEntryId, t -> !Objects.equals(theMostRecentTxLogEntryId, t));
        }

        /**
         * Fetch a transaction log entry by ID and return all details (includes the body)
         */
        public TransactionLogEventsJson.TransactionLogEventJson getTransactionLogEntryById(Long theId) {
                return myRestClient.get().uri("/transaction-log/clustermgr/event/" +theId+ "?includeBody=true").retrieve().body(TransactionLogEventsJson.TransactionLogEventJson.class);
        }

        /**
         * Perform a generic GET request to the specified path and return the response as JsonNode
         *
         * @param thePath The path to perform the GET request on
         * @return The response as JsonNode
         */
        @Nonnull
        public JsonNode get(String thePath) {
                Validate.notEmpty(thePath, "Path is required");
                JsonNode result = myRestClient
                        .get()
                        .uri(thePath)
                        .retrieve()
                        .body(JsonNode.class);
                return Objects.requireNonNull(result);
        }

}