/*
/*
 * $Id$
 *
 * Copyright (c) 1996, 2009, 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 com.sun.interview;

import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Map;
import java.util.ResourceBundle;

/**
 * A {@link Question question} to which the response is an IP address.
 * Both IPv4 and IPv6 addresses are supported.
 */
public abstract class InetAddressQuestion extends Question {

    /**
     * A constant to indicate that only IPv4 addresses should be used.
     */
    public static final int IPv4 = 0;
    /**
     * A constant to indicate that IPv6 addresses should be used. Note that
     * IPv6 includes IPv4 addresses.
     */
    public static final int IPv6 = 1;
    private static final ResourceBundle i18n = Interview.i18n;
    /**
     * The current (default or latest) response to this question.
     */
    protected InetAddress value;
    /**
     * The cached string value for this question
     */
    private String stringValue;
    /**
     * A temporary value, used to avoid changing the API for setValue/setStringValue
     */
    private transient String newStringValue;
    private InetAddress[] suggestions;
    /**
     * The default response for this question.
     */
    private InetAddress defaultValue;
    private boolean valid;
    private int type = IPv4;
    private int style = IPv4;

    /**
     * Create a question with a nominated tag.
     *
     * @param interview The interview containing this question.
     * @param tag       A unique tag to identify this specific question.
     */
    protected InetAddressQuestion(Interview interview, String tag) {
        super(interview, tag);
        clear();
        setDefaultValue(value);
    }


    /**
     * Create a question with a nominated tag.
     *
     * @param interview The interview containing this question.
     * @param tag       A unique tag to identify this specific question.
     * @param type      A value to (IPv4 or IPv6) to indicate the type of
     *                  address used by the question.
     */
    protected InetAddressQuestion(Interview interview, String tag, int type) {
        super(interview, tag);
        setType(type);
        clear();
        setDefaultValue(value);
    }

    /**
     * Compare two network address objects for equality.
     *
     * @param i1 The first address to be compared, or null.
     * @param i2 The other address to be compared, or null.
     * @return true if both arguments are null, or if both represent the
     * same network address.
     */
    protected static boolean equal(InetAddress i1, InetAddress i2) {
        return i1 == null ? i2 == null : i1.equals(i2);
    }

    /**
     * Get the type of addresses (IPv4 or IPv6) that will be accepted by this question.
     *
     * @return the type of address that will be accepted by this question
     * @see #setType
     */
    public int getType() {
        return type;
    }

    /**
     * Set the type of addresses (IPv4 or IPv6) that should be accepted by this question.
     *
     * @param type the type of address that should be accepted by this question
     * @see #getType
     */
    protected void setType(int type) {
        if (type != IPv4 && type != IPv6) {
            throw new IllegalArgumentException();
        }

        this.type = type;
    }

    /**
     * Get the presentation style (IPv4 or IPv6) for this question.
     * This is only a hint. Setting the type to IPv6 or setting suggestions
     * may cause the actual presentation style to be IPv6.
     * In IPv4 style, the data entry is four dotted decimal fields.
     * In IPv6 style, the data entry is a single type in field, with
     * an associated lookup button.
     *
     * @return the presentation style for this question
     * @see #setStyle
     */
    public int getStyle() {
        return style;
    }

    /**
     * Set the presentation style (IPv4 or IPv6) for this question.
     * In IPv4 style, the data entry is four dotted decimal fields.
     * In IPv6 style, the data entry is a single type in field, with
     * an associated lookup button.
     *
     * @param style the presentation style for this question
     * @see #getStyle
     */
    protected void setStyle(int style) {
        if (style != IPv4 && style != IPv6) {
            throw new IllegalArgumentException();
        }

        this.style = style;
    }

    /**
     * Get the suggested responses to this question, or null if none.
     *
     * @return The suggestions.
     * @see #setSuggestions
     */
    public InetAddress[] getSuggestions() {
        return suggestions;
    }

    /**
     * Set the set of suggested responses.
     *
     * @param newSuggestions The values to be set, or null if none
     * @throws IllegalArgumentException if any except the first of the values
     *                                  in the array are null
     * @see #getSuggestions
     */
    public void setSuggestions(InetAddress... newSuggestions) {
        if (newSuggestions != null) {
            // allow the first entry to be null
            for (int i = 1; i < newSuggestions.length; i++) {
                if (newSuggestions[i] == null) {
                    throw new IllegalArgumentException();
                }
            }
        }

        suggestions = newSuggestions;
    }

    /**
     * Get the default response for this question.
     *
     * @return the default response for this question.
     * @see #setDefaultValue
     */
    public InetAddress getDefaultValue() {
        return defaultValue;
    }

    /**
     * Set the default response for this question,
     * used by the clear method.
     *
     * @param v the default response for this question.
     * @see #getDefaultValue
     */
    public void setDefaultValue(InetAddress v) {
        defaultValue = v;
    }

    /**
     * Get the current (default or latest) response to this question.
     * If the question type is set to IPv4, a valid response will be
     * an Inet4Address; otherwise, if the question type is set to IPv6,
     * a valid response will be an Inet4Address or an Inet6Address
     *
     * @return The current value.
     * @see #setValue
     */
    public InetAddress getValue() {
        return value;
    }

    /**
     * Set the current value.
     * Although any value can be set, if the value is to be considered valid
     * it must be an Inet4Address if the question type is set to IPv4,
     * or either an Inet4Address or an Inet6Address if the question type
     * is set to IPv6.
     *
     * @param newValue The value to be set.
     * @see #getValue
     */
    public void setValue(InetAddress newValue) {
        InetAddress oldValue = value;
        value = newValue;
        stringValue = newStringValue;  // only non-null if called from setValue(String s)
        newStringValue = null;

        valid = value == null ? false
                : type == IPv4 ? (value instanceof Inet4Address)
                : true;

        if (!equal(value, oldValue)) {
            interview.updatePath(this);
            interview.setEdited(true);
        }
    }

    /**
     * Set the current value.
     *
     * @param newValue The value to be set.
     * @see #getValue
     */
    @Override
    public void setValue(String newValue) throws Interview.Fault {
        InetAddress v = parse(newValue);

        newStringValue = newValue;
        setValue(v);
    }

    /**
     * Verify this question is on the current path, and if it is,
     * return the current value.
     *
     * @return the current value of this question
     * @throws Interview.NotOnPathFault if this question is not on the
     *                                  current path
     * @see #getValue
     */
    public InetAddress getValueOnPath()
            throws Interview.NotOnPathFault {
        interview.verifyPathContains(this);
        return getValue();
    }

    @Override
    public String getStringValue() {
        if (stringValue == null && value != null) {
            stringValue = value.getHostAddress();
        }

        return stringValue;
    }

    @Override
    public boolean isValueValid() {
        return valid; // set by setValue
    }

    @Override
    public boolean isValueAlwaysValid() {
        return false;
    }

    private InetAddress parse(String s) {
        if (s == null || s.isEmpty()) {
            return null;
        }

        // scan the string to see if it looks reasonable:
        // - an IPv4 string contains only digits and dots
        // - an IPv6 string contains hex digits, dots and colons
        //   with at least one colon
        // this is intended to prevent calling erroneously calling
        // InetAddress.getByName with a hostname and getting a
        // false positive result

        boolean seenAlpha = false;
        boolean seenDigit = false;
        boolean seenDot = false;
        boolean seenColon = false;
        int slen = s.length();
        for (int i = 0; i < slen; i++) {
            char c = s.charAt(i);
            switch (c) {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    // always valid
                    seenDigit = true;
                    break;

                case '.':
                    // always valid
                    seenDot = true;
                    break;

                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f':
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F':
                    // invalid for IPv4, valid for IPv6
                    if (type == IPv4) {
                        return null;
                    }

                    seenAlpha = true;
                    break;

                case ':':
                    // invalid for IPv4; at least 1 required for IPv6
                    if (type == IPv4) {
                        return null;
                    }

                    seenColon = true;
                    break;

                default:
                    return null;
            }
        }

        if (type == IPv6 && !(seenColon || seenDot && seenDigit && !seenAlpha)) {
            return null;
        }

        try {
            return InetAddress.getByName(s);
        } catch (UnknownHostException e) {
            return null;
        }
    }

    /**
     * Clear any response to this question, resetting the value
     * back to its initial state.
     */
    @Override
    public void clear() {
        setValue(defaultValue);
    }

    /**
     * Save the value for this question in a dictionary, using
     * the tag as the key.
     *
     * @param data The map in which to save the value for this question.
     */
    @Override
    protected void save(Map<String, String> data) {
        String s = getStringValue();
        if (s != null) {
            data.put(tag, s);
        }
    }
}
