/*-
 * #%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.ISmileTestHttpClient;
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.hl7v2.HL7Exception;
import ca.uhn.hl7v2.model.Message;
import ca.uhn.hl7v2.parser.PipeParser;
import com.google.common.base.Charsets;
import jakarta.annotation.Nonnull;
import jakarta.annotation.Nullable;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.springframework.web.client.RestClient;

import java.util.Base64;
import java.util.Objects;

import static org.springframework.http.HttpHeaders.AUTHORIZATION;
import static org.springframework.http.HttpHeaders.CONTENT_TYPE;

/**
 * A REST client for sending HL7V2 messages to a Smile CDR server.
 */
public class HL7V2RestClient implements AutoCloseable {
        private static final String HL7V2_MEDIA_TYPE = "application/hl7-v2";
        private final RestClient myRestClient;
        private final PipeParser myParser;

        /**
         * 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;

        /**
         * Constructor with a pre-configured RestClient.
         *
         * @param theRestClient The RestClient to use
         */
        HL7V2RestClient(RestClient theRestClient) {
                this(theRestClient, null);
        }

        private HL7V2RestClient(RestClient theRestClient, @Nullable HttpClientOwnership theOwnership) {
                myRestClient = theRestClient;
                myParser = new PipeParser();
                myOwnership = theOwnership;
        }

        /**
         * Opens a client 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, so this client shares its session rather than starting another.
         * <p>
         * The client is configured the way every other Smile test client is: generous timeouts and
         * <b>redirects disabled</b>, so a {@literal 3xx} is returned rather than followed.
         *
         * @param theBaseUrl  The base URL of the HL7V2 endpoint, including port if needed.
         * @param theUsername The username for authentication (optional)
         * @param thePassword The password for authentication (optional)
         * @return A new HL7V2RestClient
         */
        public static @Nonnull HL7V2RestClient open(
                        @Nonnull String theBaseUrl, @Nullable String theUsername, @Nullable String thePassword) {
                return clientOn(HttpClientOwnership.resolve(null), theBaseUrl, theUsername, thePassword);
        }

        /**
         * 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 HL7V2 endpoint, including port if needed.
         * @param theUsername The username for authentication (optional)
         * @param thePassword The password for authentication (optional)
         * @return A new HL7V2RestClient
         * @see ca.cdr.test.app.clients.common.RequestFactoryUtil#wrap(ISmileTestHttpClient)
         */
        public static @Nonnull HL7V2RestClient issuingOn(
                        @Nonnull SmileTestHttpClient theHttpClient,
                        @Nonnull String theBaseUrl,
                        @Nullable String theUsername,
                        @Nullable String thePassword) {
                return clientOn(HttpClientOwnership.resolve(theHttpClient), theBaseUrl, theUsername, thePassword);
        }

        /**
         * @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 HL7V2RestClient build(
                        @Nonnull String theBaseUrl, @Nullable String theUsername, @Nullable String thePassword) {
                return open(theBaseUrl, theUsername, thePassword);
        }

        private static @Nonnull HL7V2RestClient clientOn(
                        @Nonnull HttpClientOwnership theOwnership,
                        @Nonnull String theBaseUrl,
                        @Nullable String theUsername,
                        @Nullable String thePassword) {
                RestClient.Builder builder = RestClient.builder()
                        .baseUrl(theBaseUrl)
                        .defaultHeader(CONTENT_TYPE, HL7V2_MEDIA_TYPE)
                        .requestFactory(RequestFactoryUtil.wrap(theOwnership.client()));
                if (!StringUtils.isBlank(theUsername) && !StringUtils.isBlank(thePassword)) {
                        builder.defaultHeader(
                                AUTHORIZATION,
                                "Basic "
                                        + Base64.getEncoder()
                                        .encodeToString((theUsername + ":" + thePassword).getBytes(Charsets.UTF_8)));
                }
                return new HL7V2RestClient(builder.build(), theOwnership);
        }

        /**
         * Send an HL7V2 message to the server.
         *
         * @param theMessage The HL7V2 message to send
         * @return The response message from the server
         * @throws HL7Exception If there is an error parsing the response
         */
        @Nonnull
        public Message sendMessage(String theMessage) throws HL7Exception {
                Validate.notEmpty(theMessage, "Message is required");

                String responseBody = myRestClient
                        .post()
                        .body(theMessage)
                        .retrieve()
                        .body(String.class);

                return myParser.parse(Objects.requireNonNull(responseBody));
        }

        /**
         * Send a pre-parsed HL7V2 message to the server.
         *
         * @param theMessage The pre-parsed HL7V2 message to send
         * @return The response message from the server
         * @throws HL7Exception If there is an error encoding the message or parsing the response
         */
        @Nonnull
        public Message sendMessage(Message theMessage) throws HL7Exception {
                Validate.notNull(theMessage, "Message is required");
                return sendMessage(theMessage.encode());
        }

        /**
         * 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();
                }
        }
}