/*

 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.net;

/**

 * This class represents a proxy setting, typically a type (http, socks) and

 * a socket address.

 * A {@code Proxy} is an immutable object.

 *

 * @see     java.net.ProxySelector

 * @author Yingxian Wang

 * @author Jean-Christophe Collet

 * @since   1.5

 */

public class Proxy {

    /**

     * Represents the proxy type.

     *

     * @since 1.5

     */

    public enum Type {

        /**

         * Represents a direct connection, or the absence of a proxy.

         */

        DIRECT,

        /**

         * Represents proxy for high level protocols such as HTTP or FTP.

         */

        HTTP,

        /**

         * Represents a SOCKS (V4 or V5) proxy.

         */

        SOCKS

    };

    private Type type;

    private SocketAddress sa;

    /**

     * A proxy setting that represents a {@code DIRECT} connection,

     * basically telling the protocol handler not to use any proxying.

     * Used, for instance, to create sockets bypassing any other global

     * proxy settings (like SOCKS):

     * <P>

     * {@code Socket s = new Socket(Proxy.NO_PROXY);}

     *

     */

    public static final Proxy NO_PROXY = new Proxy();

    // Creates the proxy that represents a {@code DIRECT} connection.

    private Proxy() {

        type = Type.DIRECT;

        sa = null;

    }

    /**

     * Creates an entry representing a PROXY connection.

     * Certain combinations are illegal. For instance, for types Http, and

     * Socks, a SocketAddress <b>must</b> be provided.

     * <P>

     * Use the {@code Proxy.NO_PROXY} constant

     * for representing a direct connection.

     *

     * @param type the {@code Type} of the proxy

     * @param sa the {@code SocketAddress} for that proxy

     * @throws IllegalArgumentException when the type and the address are

     * incompatible

     */

    public Proxy(Type type, SocketAddress sa) {

        if ((type == Type.DIRECT) || !(sa instanceof InetSocketAddress))

            throw new IllegalArgumentException("type " + type + " is not compatible with address " + sa);

        this.type = type;

        this.sa = sa;

    }

    /**

     * Returns the proxy type.

     *

     * @return a Type representing the proxy type

     */

    public Type type() {

        return type;

    }

    /**

     * Returns the socket address of the proxy, or

     * {@code null} if its a direct connection.

     *

     * @return a {@code SocketAddress} representing the socket end

     *         point of the proxy

     */

    public SocketAddress address() {

        return sa;

    }

    /**

     * Constructs a string representation of this Proxy.

     * This String is constructed by calling toString() on its type

     * and concatenating " @ " and the toString() result from its address

     * if its type is not {@code DIRECT}.

     *

     * @return  a string representation of this object.

     */

    public String toString() {

        if (type() == Type.DIRECT)

            return "DIRECT";

        return type() + " @ " + address();

    }

        /**

     * Compares this object against the specified object.

     * The result is {@code true} if and only if the argument is

     * not {@code null} and it represents the same proxy as

     * this object.

     * <p>

     * Two instances of {@code Proxy} represent the same

     * address if both the SocketAddresses and type are equal.

     *

     * @param   obj   the object to compare against.

     * @return  {@code true} if the objects are the same;

     *          {@code false} otherwise.

     * @see java.net.InetSocketAddress#equals(java.lang.Object)

     */

    public final boolean equals(Object obj) {

        if (obj == null || !(obj instanceof Proxy))

            return false;

        Proxy p = (Proxy) obj;

        if (p.type() == type()) {

            if (address() == null) {

                return (p.address() == null);

            } else

                return address().equals(p.address());

        }

        return false;

    }

    /**

     * Returns a hashcode for this Proxy.

     *

     * @return  a hash code value for this Proxy.

     */

    public final int hashCode() {

        if (address() == null)

            return type().hashCode();

        return type().hashCode() + address().hashCode();

    }

}