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

import ca.uhn.fhir.model.api.Include;
import ca.uhn.fhir.rest.api.SearchStyleEnum;
import ca.uhn.fhir.rest.api.SearchTotalModeEnum;
import ca.uhn.fhir.rest.api.SortSpec;
import ca.uhn.fhir.rest.param.DateRangeParam;
import ca.uhn.fhir.rest.param.UriAndListParam;
import ca.uhn.fhir.rest.param.UriOrListParam;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multimaps;
import jakarta.annotation.Nonnull;
import jakarta.annotation.Nullable;
import org.apache.commons.lang3.Validate;

import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static org.apache.commons.lang3.ObjectUtils.defaultIfNull;

/**
 * This class represents a FHIR Gateway Search request
 */
public class SearchRequest extends BaseRequest<SearchRequest> {

        private ListMultimap<String, String> myParameters = EMPTY_STRING_MULTIMAP;
        private Set<Include> myIncludes = Collections.emptySet();
        private Set<Include> myRevIncludes = Collections.emptySet();
        private SortSpec mySort;
        private Integer myCount;
        private SearchTotalModeEnum myTotalMode;
        private Integer myOffset;
        private DateRangeParam myLastUpdated;
        private UriAndListParam myProfile;

        @Nullable
        private SearchStyleEnum mySearchStyle;

        /**
         * Constructor
         */
        public SearchRequest() {
                // nothing
        }

        /**
         * Copy constructor
         */
        public SearchRequest(SearchRequest theSearchRequest) {
                super(theSearchRequest);

                if (!theSearchRequest.getParameters().isEmpty()) {
                        myParameters = ArrayListMultimap.create();
                        myParameters.putAll(theSearchRequest.getParameters());
                }

                if (!theSearchRequest.getIncludes().isEmpty()) {
                        myIncludes = new HashSet<>();
                        for (Include next : theSearchRequest.getIncludes()) {
                                myIncludes.add(next.toLocked());
                        }
                }

                if (!theSearchRequest.getRevIncludes().isEmpty()) {
                        myRevIncludes = new HashSet<>();
                        for (Include next : theSearchRequest.getRevIncludes()) {
                                myRevIncludes.add(next.toLocked());
                        }
                }

                if (theSearchRequest.getSort() != null) {
                        mySort = clone(theSearchRequest.getSort());
                }

                if (theSearchRequest.getLastUpdated() != null) {
                        myLastUpdated = new DateRangeParam(
                                        theSearchRequest.getLastUpdated().getLowerBound() != null
                                                        ? theSearchRequest.getLastUpdated().getLowerBound().getValueAsString()
                                                        : null,
                                        theSearchRequest.getLastUpdated().getUpperBound() != null
                                                        ? theSearchRequest.getLastUpdated().getUpperBound().getValueAsString()
                                                        : null);
                }

                if (theSearchRequest.getProfile() != null) {
                        myProfile = new UriAndListParam();
                        for (UriOrListParam uriOrListParam : theSearchRequest.getProfile().getValuesAsQueryTokens()) {
                                myProfile.addAnd(uriOrListParam);
                        }
                }

                myCount = theSearchRequest.getCount();
                myOffset = theSearchRequest.getOffset();
                myTotalMode = theSearchRequest.getTotalMode();
                mySearchStyle = theSearchRequest.getSearchStyle();
        }

        private static SortSpec clone(SortSpec theSort) {
                if (theSort == null) {
                        return null;
                }
                return new SortSpec(theSort.getParamName(), theSort.getOrder(), clone(theSort.getChain()));
        }

        /**
         * Specifies the search form (GET vs POST) to use for this search. If set to
         * <code>null</code>, the default will be used.
         */
        @Nullable
        public SearchStyleEnum getSearchStyle() {
                return mySearchStyle;
        }

        /**
         * Specifies the search form (GET vs POST) to use for this search. If set to
         * <code>null</code>, the default will be used.
         */
        public void setSearchStyle(@Nullable SearchStyleEnum theSearchStyle) {
                mySearchStyle = theSearchStyle;
        }

        public Multimap<String, String> getParameters() {
                return Multimaps.unmodifiableMultimap(myParameters);
        }

        public SearchRequest setParameters(Map<String, List<String>> theParameters) {
                Validate.notNull(theParameters, "theParameters must not be null");
                myParameters = ArrayListMultimap.create();
                for (Map.Entry<String, List<String>> next : theParameters.entrySet()) {
                        myParameters.putAll(next.getKey(), next.getValue());
                }
                return this;
        }

        /**
         * Remove all parameters with the given name
         *
         * @return Returns any parameter values that were removed
         */
        public List<String> removeParameters(String theName) {
                if (!myParameters.isEmpty()) {
                        return Collections.unmodifiableList(myParameters.removeAll(theName));
                } else {
                        return Collections.emptyList();
                }
        }

        /**
         * Remove the parameter with the given name and value, if found. Any other parameters with the same name are kept.
         *
         * @param theName  The parameter name
         * @param theValue The parameter value
         * @return Returns <code>true</code> if a parameter value was removed
         */
        public boolean removeParameter(String theName, String theValue) {
                return myParameters.remove(theName, theValue);
        }

        /**
         * Returns the first parameter value for a given parameter name (returns <code>null</code> if no parameters match the given name)
         *
         * @param theName The parameter name
         * @return The value, or <code>null</code>
         */
        @Nullable
        public String getParameter(String theName) {
                List<String> values = getParameters(theName);
                if (!values.isEmpty()) {
                        return values.get(0);
                }
                return null;
        }

        /**
         * Returns a List of parameter values for the given name. Will not return <code>null</code>.
         *
         * @param theName The parameter name
         * @return A List of values, or an empty List
         */
        @Nonnull
        public List<String> getParameters(String theName) {
                List<String> values = myParameters.get(theName);
                values = defaultIfNull(values, Collections.emptyList());
                return Collections.unmodifiableList(values);
        }

        public Set<Include> getIncludes() {
                return myIncludes;
        }

        public SearchRequest setIncludes(Set<Include> theIncludes) {
                Validate.notNull(theIncludes, "theIncludes must not be null");
                myIncludes = theIncludes;
                return this;
        }

        public Set<Include> getRevIncludes() {
                return myRevIncludes;
        }

        public SearchRequest setRevIncludes(Set<Include> theRevIncludes) {
                Validate.notNull(theRevIncludes, "theRevIncludes must not be null");
                myRevIncludes = theRevIncludes;
                return this;
        }

        public SortSpec getSort() {
                return mySort;
        }

        public SearchRequest setSort(SortSpec theSort) {
                mySort = theSort;
                return this;
        }

        public Integer getCount() {
                return myCount;
        }

        public SearchRequest setCount(Integer theCount) {
                myCount = theCount;
                return this;
        }

        public Integer getOffset() {
                return myOffset;
        }

        public SearchRequest setOffset(Integer theOffset) {
                myOffset = theOffset;
                return this;
        }

        public DateRangeParam getLastUpdated() {
                return myLastUpdated;
        }

        public SearchRequest setLastUpdated(DateRangeParam theLastUpdated) {
                myLastUpdated = theLastUpdated;
                return this;
        }

        public UriAndListParam getProfile() {
                return myProfile;
        }

        public SearchRequest setProfile(UriAndListParam theProfile) {
                myProfile = theProfile;
                return this;
        }

        public SearchTotalModeEnum getTotalMode() {
                return myTotalMode;
        }

        public SearchRequest setTotalMode(SearchTotalModeEnum theTotalMode) {
                myTotalMode = theTotalMode;
                return this;
        }

        /**
         * Add a new search parameter
         */
        public void addParameter(String theName, String theValue) {
                Validate.notBlank(theName, "theName must not be empty");
                Validate.notBlank(theValue, "theValue must not be empty");
                if (myParameters.isEmpty()) {
                        myParameters = ArrayListMultimap.create();
                }
                myParameters.put(theName, theValue);
        }
}