package ezvcard.util;

import java.net.URI;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.function.IntConsumer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.IntStream;

import ezvcard.Messages;

/*
 Copyright (c) 2012-2026, Michael Angstadt
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met: 

 1. Redistributions of source code must retain the above copyright notice, this
 list of conditions and the following disclaimer. 
 2. Redistributions in binary form must reproduce the above copyright notice,
 this list of conditions and the following disclaimer in the documentation
 and/or other materials provided with the distribution. 

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 The views and conclusions contained in the software and documentation are those
 of the authors and should not be interpreted as representing official policies, 
 either expressed or implied, of the FreeBSD Project.
 */

/**
 * <p>
 * Represents a URI for encoding a geographical position.
 * </p>
 * <p>
 * Example geo URI: {@code geo:40.714623,-74.006605}
 * </p>
 * <p>
 * This class is immutable. Use the {@link Builder} object to construct a new
 * instance, or the {@link #parse} method to parse a geo URI string.
 * </p>
 * <p>
 * <b>Examples:</b>
 * </p>
 * 
 * <pre class="brush:java">
 * GeoUri uri = new GeoUri.Builder(40.714623, -74.006605).coordC(1.1).build();
 * GeoUri uri = GeoUri.parse("geo:40.714623,-74.006605,1.1");
 * GeoUri copy = new GeoUri.Builder(original).coordC(2.1).build();
 * </pre>
 * @author Michael Angstadt
 * @see <a href="http://tools.ietf.org/html/rfc5870">RFC 5870</a>
 */
public final class GeoUri {
        /**
         * The coordinate reference system used by GPS (the default).
         */
        public static final String CRS_WGS84 = "wgs84";

        private static final String SCHEME = "geo:";

        /**
         * The characters which are allowed to exist un-encoded inside of a
         * parameter value.
         */
        private static final boolean[] validParameterValueCharacters = new boolean[128];
        static {
                IntConsumer markAsValidCharacter = c -> validParameterValueCharacters[c] = true;
                IntStream.rangeClosed('0', '9').forEach(markAsValidCharacter);
                IntStream.rangeClosed('A', 'Z').forEach(markAsValidCharacter);
                IntStream.rangeClosed('a', 'z').forEach(markAsValidCharacter);
                "!$&'()*+-.:[]_~".chars().forEach(markAsValidCharacter);
        }

        private static final String PARAM_CRS = "crs";
        private static final String PARAM_UNCERTAINTY = "u";

        private final Double coordA;
        private final Double coordB;
        private final Double coordC;
        private final String crs;
        private final Double uncertainty;
        private final Map<String, String> parameters;

        private GeoUri(Builder builder) {
                this.coordA = (builder.coordA == null) ? Double.valueOf(0.0) : builder.coordA;
                this.coordB = (builder.coordB == null) ? Double.valueOf(0.0) : builder.coordB;
                this.coordC = builder.coordC;
                this.crs = builder.crs;
                this.uncertainty = builder.uncertainty;
                this.parameters = Collections.unmodifiableMap(builder.parameters);
        }

        /**
         * Parses a geo URI string.
         * @param uri the URI string (e.g. "geo:40.714623,-74.006605")
         * @return the parsed geo URI
         * @throws IllegalArgumentException if the string is not a valid geo URI
         */
        public static GeoUri parse(String uri) {
                return new Parser(uri).parse();
        }

        private static class Parser {
                private static final Pattern hexPattern = Pattern.compile("(?i)%([0-9a-f]{2})");

                private final String uri;
                private final CharIterator it;
                private final Builder builder;
                private final ClearableStringBuilder buffer;

                private String paramName;
                private boolean coordinatesDone;

                public Parser(String uri) {
                        this.uri = uri;
                        checkScheme();

                        builder = new Builder(null, null);
                        buffer = new ClearableStringBuilder();

                        it = new CharIterator(uri, SCHEME.length());
                }

                private void checkScheme() {
                        if (uri.length() < SCHEME.length() || !uri.substring(0, SCHEME.length()).equalsIgnoreCase(SCHEME)) {
                                //not a geo URI
                                throw Messages.INSTANCE.getIllegalArgumentException(18, SCHEME);
                        }
                }

                public GeoUri parse() {
                        //URI format: geo:LAT,LONG;prop1=value1;prop2=value2

                        while (it.hasNext()) {
                                char c = it.next();
                                processCharacter(c);
                        }

                        if (coordinatesDone) {
                                handleEndOfParameter();
                        } else {
                                handleEndOfCoordinate();
                                if (builder.coordB == null) {
                                        throw Messages.INSTANCE.getIllegalArgumentException(21);
                                }
                        }

                        return builder.build();
                }

                private void processCharacter(char c) {
                        if (c == ',' && !coordinatesDone) {
                                handleEndOfCoordinate();
                                return;
                        }

                        if (c == ';') {
                                if (coordinatesDone) {
                                        handleEndOfParameter();
                                        paramName = null;
                                } else {
                                        handleEndOfCoordinate();
                                        if (builder.coordB == null) {
                                                throw Messages.INSTANCE.getIllegalArgumentException(21);
                                        }
                                        coordinatesDone = true;
                                }
                                return;
                        }

                        if (c == '=' && coordinatesDone && paramName == null) {
                                paramName = buffer.getAndClear();
                                return;
                        }

                        buffer.append(c);
                }

                private void handleEndOfCoordinate() {
                        String s = buffer.getAndClear();

                        if (builder.coordA == null) {
                                builder.coordA = parseCoord(s, "A");
                                return;
                        }

                        if (builder.coordB == null) {
                                builder.coordB = parseCoord(s, "B");
                                return;
                        }

                        if (builder.coordC == null) {
                                builder.coordC = parseCoord(s, "C");
                                return;
                        }
                }

                private Double parseCoord(String s, String letter) {
                        try {
                                return Double.parseDouble(s);
                        } catch (NumberFormatException e) {
                                throw new IllegalArgumentException(Messages.INSTANCE.getExceptionMessage(22, letter), e);
                        }
                }

                private void addParameter(String name, String value) {
                        value = decodeParameterValue(value);

                        if (PARAM_CRS.equalsIgnoreCase(name)) {
                                builder.crs = value;
                                return;
                        }

                        if (PARAM_UNCERTAINTY.equalsIgnoreCase(name)) {
                                try {
                                        builder.uncertainty = Double.valueOf(value);
                                        return;
                                } catch (NumberFormatException e) {
                                        //if it can't be parsed, then treat it as an ordinary parameter
                                }
                        }

                        builder.parameters.put(name, value);
                }

                private void handleEndOfParameter() {
                        String s = buffer.getAndClear();

                        if (paramName == null) {
                                if (!s.isEmpty()) {
                                        addParameter(s, "");
                                }
                                return;
                        }

                        addParameter(paramName, s);
                }

                /**
                 * Decodes escaped characters in a parameter value.
                 * @param value the parameter value
                 * @return the decoded value
                 */
                private String decodeParameterValue(String value) {
                        Matcher m = hexPattern.matcher(value);
                        StringBuffer sb = null;

                        while (m.find()) {
                                if (sb == null) {
                                        sb = new StringBuffer(value.length());
                                }

                                int hex = Integer.parseInt(m.group(1), 16);
                                m.appendReplacement(sb, Character.toString((char) hex));
                        }

                        if (sb == null) {
                                return value;
                        }

                        m.appendTail(sb);
                        return sb.toString();
                }
        }

        /**
         * Gets the first coordinate (latitude).
         * @return the first coordinate or null if there is none
         */
        public Double getCoordA() {
                return coordA;
        }

        /**
         * Gets the second coordinate (longitude).
         * @return the second coordinate or null if there is none
         */
        public Double getCoordB() {
                return coordB;
        }

        /**
         * Gets the third coordinate (altitude).
         * @return the third coordinate or null if there is none
         */
        public Double getCoordC() {
                return coordC;
        }

        /**
         * Gets the coordinate reference system.
         * @return the coordinate reference system or null if using the default
         * (WGS-84)
         */
        public String getCrs() {
                return crs;
        }

        /**
         * Gets the uncertainty (how accurate the coordinates are).
         * @return the uncertainty (in meters) or null if not set
         */
        public Double getUncertainty() {
                return uncertainty;
        }

        /**
         * Gets a parameter value.
         * @param name the parameter name
         * @return the parameter value or null if not found
         */
        public String getParameter(String name) {
                return parameters.get(name);
        }

        /**
         * Gets all the parameters.
         * @return all the parameters
         */
        public Map<String, String> getParameters() {
                return parameters;
        }

        /**
         * Creates a {@link URI} object from this geo URI.
         * @return the {@link URI} object
         */
        public URI toUri() {
                return URI.create(toString());
        }

        /**
         * Converts this geo URI to its string representation.
         * @return the geo URI's string representation
         */
        @Override
        public String toString() {
                return toString(6);
        }

        /**
         * Converts this geo URI to its string representation.
         * @param decimals the number of decimals to display for floating point
         * values
         * @return the geo URI's string representation
         */
        public String toString(int decimals) {
                return new Writer(decimals).write();
        }

        private class Writer {
                private final VCardFloatFormatter formatter;
                private final StringBuilder sb;

                public Writer(int decimals) {
                        formatter = new VCardFloatFormatter(decimals);
                        sb = new StringBuilder(SCHEME);
                }

                public String write() {
                        sb.append(formatter.format(coordA));
                        sb.append(',');
                        sb.append(formatter.format(coordB));

                        if (coordC != null) {
                                sb.append(',');
                                sb.append(coordC);
                        }

                        //if the CRS is WGS-84, then it doesn't have to be displayed
                        if (crs != null && !crs.equalsIgnoreCase(CRS_WGS84)) {
                                writeParameter(PARAM_CRS, crs);
                        }

                        if (uncertainty != null) {
                                writeParameter(PARAM_UNCERTAINTY, formatter.format(uncertainty));
                        }

                        parameters.forEach(this::writeParameter);

                        return sb.toString();
                }

                /**
                 * Writes a parameter to a string.
                 * @param name the parameter name
                 * @param value the parameter value
                 * @param sb the string to write to
                 */
                private void writeParameter(String name, String value) {
                        sb.append(';').append(name).append('=').append(encodeParameterValue(value));
                }

                /**
                 * Encodes a string for safe inclusion in a parameter value.
                 * @param value the string to encode
                 * @return the encoded value
                 */
                private String encodeParameterValue(String value) {
                        StringBuilder encodedValue = null;
                        CharIterator it = new CharIterator(value);

                        while (it.hasNext()) {
                                char c = it.next();
                                if (c < validParameterValueCharacters.length && validParameterValueCharacters[c]) {
                                        if (encodedValue != null) {
                                                encodedValue.append(c);
                                        }
                                } else {
                                        if (encodedValue == null) {
                                                encodedValue = new StringBuilder(value.length() * 2);
                                                encodedValue.append(value, 0, it.index());
                                        }
                                        String hex = Integer.toString(c, 16);
                                        encodedValue.append('%').append(hex);
                                }
                        }

                        return (encodedValue == null) ? value : encodedValue.toString();
                }
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + StringUtils.hashIgnoreCase(parameters);
                result = prime * result + StringUtils.hashIgnoreCase(coordA, coordB, coordC, crs, uncertainty);
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj) return true;
                if (obj == null) return false;
                if (getClass() != obj.getClass()) return false;
                GeoUri other = (GeoUri) obj;
                return Objects.equals(coordA, other.coordA) && Objects.equals(coordB, other.coordB) && Objects.equals(coordC, other.coordC) && StringUtils.equalsIgnoreCase(crs, other.crs) && Objects.equals(uncertainty, other.uncertainty) && StringUtils.equalsIgnoreCase(parameters, other.parameters);
        }

        /**
         * Builder class for {@link GeoUri}.
         * @author Michael Angstadt
         */
        public static class Builder {
                private Double coordA;
                private Double coordB;
                private Double coordC;
                private String crs;
                private Double uncertainty;
                private Map<String, String> parameters;
                private CharacterBitSet validParamChars = new CharacterBitSet("a-zA-Z0-9-");

                /**
                 * Creates a new {@link GeoUri} builder.
                 * @param coordA the first coordinate (i.e. latitude)
                 * @param coordB the second coordinate (i.e. longitude)
                 */
                public Builder(Double coordA, Double coordB) {
                        parameters = new LinkedHashMap<>(0); //set initial size to 0 because parameters are rarely used
                        coordA(coordA);
                        coordB(coordB);
                }

                /**
                 * Creates a new {@link GeoUri} builder.
                 * @param original the {@link GeoUri} object to copy from
                 */
                public Builder(GeoUri original) {
                        coordA(original.coordA);
                        coordB(original.coordB);
                        this.coordC = original.coordC;
                        this.crs = original.crs;
                        this.uncertainty = original.uncertainty;
                        this.parameters = new LinkedHashMap<>(original.parameters);
                }

                /**
                 * Sets the first coordinate (latitude).
                 * @param coordA the first coordinate
                 * @return this
                 */
                public Builder coordA(Double coordA) {
                        this.coordA = coordA;
                        return this;
                }

                /**
                 * Sets the second coordinate (longitude).
                 * @param coordB the second coordinate
                 * @return this
                 */
                public Builder coordB(Double coordB) {
                        this.coordB = coordB;
                        return this;
                }

                /**
                 * Sets the third coordinate (altitude).
                 * @param coordC the third coordinate or null to remove
                 * @return this
                 */
                public Builder coordC(Double coordC) {
                        this.coordC = coordC;
                        return this;
                }

                /**
                 * Sets the coordinate reference system.
                 * @param crs the coordinate reference system (can only contain letters,
                 * numbers, and hyphens) or null to use the default (WGS-84)
                 * @throws IllegalArgumentException if the CRS name contains invalid
                 * characters
                 * @return this
                 */
                public Builder crs(String crs) {
                        if (crs != null && !validParamChars.containsOnly(crs)) {
                                throw Messages.INSTANCE.getIllegalArgumentException(24);
                        }
                        this.crs = crs;
                        return this;
                }

                /**
                 * Sets the uncertainty (how accurate the coordinates are).
                 * @param uncertainty the uncertainty (in meters) or null to remove
                 * @return this
                 */
                public Builder uncertainty(Double uncertainty) {
                        this.uncertainty = uncertainty;
                        return this;
                }

                /**
                 * Adds a parameter.
                 * @param name the parameter name (can only contain letters, numbers,
                 * and hyphens)
                 * @param value the parameter value or null to remove the parameter
                 * @throws IllegalArgumentException if the parameter name contains
                 * invalid characters
                 * @return this
                 */
                public Builder parameter(String name, String value) {
                        if (!validParamChars.containsOnly(name)) {
                                throw Messages.INSTANCE.getIllegalArgumentException(23);
                        }

                        if (value == null) {
                                parameters.remove(name);
                        } else {
                                parameters.put(name, value);
                        }
                        return this;
                }

                /**
                 * Builds the final {@link GeoUri} object.
                 * @return the object
                 */
                public GeoUri build() {
                        return new GeoUri(this);
                }
        }
}