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

// Created by claude-opus-4-5-20251101

import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Parser for consent policy names that may contain query parameters.
 * Splits policy names on '?' and parses query parameters with URL decoding.
 *
 * <p>Examples:
 * <ul>
 *   <li>{@code "RedactFhirPathsWhen?_type=Patient"} ? base="RedactFhirPathsWhen", params={_type:[Patient]}</li>
 *   <li>{@code "RedactFhirPathsWhen?a=b&a=c"} ? base="RedactFhirPathsWhen", params={a:[[b],[c]]}</li>
 *   <li>{@code "RedactFhirPathsWhen?a=b,c&a=d"} ? base="RedactFhirPathsWhen", params={a:[[b,c],[d]]}</li>
 * </ul>
 */
public class ParameterizedPolicyQueryParameterParser {

        private final String myBasePolicyName;
        private final Map<String, List<List<String>>> myParameters;

        private ParameterizedPolicyQueryParameterParser(
                        String theBasePolicyName, Map<String, List<List<String>>> theParameters) {
                myBasePolicyName = theBasePolicyName;
                myParameters = theParameters;
        }

        /**
         * Parse a policy name string that may contain query parameters.
         *
         * @param thePolicyNameWithParams the policy name, optionally followed by ?key=value&key2=value2
         * @return a parsed result containing the base policy name and parameters
         */
        public static ParameterizedPolicyQueryParameterParser parse(String thePolicyNameWithParams) {
                if (thePolicyNameWithParams == null) {
                        return new ParameterizedPolicyQueryParameterParser(null, Collections.emptyMap());
                }

                int questionMarkIndex = thePolicyNameWithParams.indexOf('?');
                if (questionMarkIndex == -1) {
                        // No query parameters
                        return new ParameterizedPolicyQueryParameterParser(thePolicyNameWithParams, Collections.emptyMap());
                }

                String baseName = thePolicyNameWithParams.substring(0, questionMarkIndex);
                String queryString = thePolicyNameWithParams.substring(questionMarkIndex + 1);

                Map<String, List<List<String>>> params = parseQueryString(queryString);

                return new ParameterizedPolicyQueryParameterParser(baseName, params);
        }

        private static Map<String, List<List<String>>> parseQueryString(String theQueryString) {
                Map<String, List<List<String>>> result = new HashMap<>();

                if (theQueryString == null || theQueryString.isEmpty()) {
                        return result;
                }

                String[] pairs = theQueryString.split("&");
                for (String pair : pairs) {
                        if (pair.isEmpty()) {
                                continue;
                        }

                        int equalsIndex = pair.indexOf('=');
                        String key;
                        String value;

                        if (equalsIndex == -1) {
                                // Key without value
                                key = urlDecode(pair);
                                value = "";
                        } else {
                                key = urlDecode(pair.substring(0, equalsIndex));
                                value = urlDecode(pair.substring(equalsIndex + 1));
                        }

                        // Split value on comma to create OR list
                        List<String> orList = splitAndTrim(value);
                        result.computeIfAbsent(key, k -> new ArrayList<>()).add(orList);
                }

                return result;
        }

        private static List<String> splitAndTrim(String theValue) {
                if (theValue == null || theValue.isEmpty()) {
                        return Collections.singletonList("");
                }
                List<String> result = new ArrayList<>();
                for (String part : theValue.split(",")) {
                        String trimmed = part.trim();
                        result.add(trimmed);
                }
                return result;
        }

        private static String urlDecode(String theValue) {
                try {
                        return URLDecoder.decode(theValue, StandardCharsets.UTF_8);
                } catch (IllegalArgumentException e) {
                        // If decoding fails, return the original value
                        return theValue;
                }
        }

        /**
         * Get the base policy name (without query parameters).
         *
         * @return the base policy name
         */
        public String getBasePolicyName() {
                return myBasePolicyName;
        }

        /**
         * Check if the policy has any parameters.
         *
         * @return true if parameters exist
         */
        public boolean hasParameters() {
                return !myParameters.isEmpty();
        }

        /**
         * Check if a specific parameter exists.
         *
         * @param theKey the parameter key
         * @return true if the parameter exists
         */
        public boolean hasParameter(String theKey) {
                List<List<String>> andLists = myParameters.get(theKey);
                return andLists != null && !andLists.isEmpty();
        }

        /**
         * Get the AND/OR structure for a parameter.
         * The outer list represents AND groups (each occurrence of the parameter).
         * The inner list represents OR values (comma-separated within one occurrence).
         *
         * @param theKey the parameter key
         * @return list of AND groups, each containing OR values, or empty list if not found
         */
        public List<List<String>> getParameter(String theKey) {
                List<List<String>> andLists = myParameters.get(theKey);
                return andLists != null ? Collections.unmodifiableList(andLists) : Collections.emptyList();
        }

        /**
         * Get the first value for a parameter.
         *
         * @param theKey the parameter key
         * @return the first value from the first AND group, or null if not found
         */
        public String getFirstParameterValue(String theKey) {
                List<List<String>> andLists = myParameters.get(theKey);
                if (andLists != null && !andLists.isEmpty()) {
                        List<String> firstOrList = andLists.get(0);
                        if (firstOrList != null && !firstOrList.isEmpty()) {
                                return firstOrList.get(0);
                        }
                }
                return null;
        }

        /**
         * Get all values for a parameter, flattened across all AND groups.
         *
         * @param theKey the parameter key
         * @return list of all values, or empty list if not found
         * @deprecated Use {@link #getParameter(String)} to access the AND/OR structure
         */
        @Deprecated
        public List<String> getParameterValues(String theKey) {
                List<List<String>> andLists = myParameters.get(theKey);
                if (andLists == null || andLists.isEmpty()) {
                        return Collections.emptyList();
                }
                List<String> flattened = new ArrayList<>();
                for (List<String> orList : andLists) {
                        flattened.addAll(orList);
                }
                return Collections.unmodifiableList(flattened);
        }

        /**
         * Get all parameters with their AND/OR structure.
         *
         * @return unmodifiable map of parameter keys to lists of AND groups
         */
        public Map<String, List<List<String>>> getAllParameters() {
                return Collections.unmodifiableMap(myParameters);
        }
}