package org.jscsi.target.settings.entry;

import org.jscsi.target.TargetServer;
import org.jscsi.target.settings.KeySet;
import org.jscsi.target.settings.NegotiationStatus;
import org.jscsi.target.settings.NegotiationType;
import org.jscsi.target.settings.NumericalValueRange;
import org.jscsi.target.settings.SingleNumericalValue;

/**
 * An {@link Entry} sub-class used for negotiating integer parameters which
 * require the iSCSI initiator to offer an interval from which the target must
 * choose the final value. Thereby the <i>key=value</i> format differs from that
 * required by the {@link NumericalEntry} class, for which <i>value</i> is a
 * single integer. The <i>value</i> part expected by this class looks like <code>1024~2048</code>, however the
 * response <i>value</i> will again be a
 * single integer from the given range.
 * <p>
 * Currently this {@link Entry} sub-class is only used for two parameters - <code>IFMarkInt</code> and
 * <code>OFMarkInt</code>. However, since the jSCSI Target does not support stream markers (
 * <code>IFMarker=No</code> and <code>OFMarker=No</code>), the correct response value to
 * <code>IFMarkInt</code> and <code>OFMarkInt</code> <i>keys</i> must be <code>Irrelevant</code>. This
 * behavior is part of the
 * {@link Entry#negotiate(org.jscsi.target.TargetServer, org.jscsi.parser.login.LoginStage, boolean, boolean, String, String, java.util.Collection)}
 * method, which will lead to correct responses without having to check for additional constraints (the
 * presence and <i>value</i> of <code>IFMarker</code> and <code>OFMarker</code> <i>key=value</i> pairs.
 * 
 * @author Andreas Ergenzinger
 */
public final class NumericalRangeEntry extends Entry {

    /**
     * A {@link NumericalValueRange} specifying the boundaries into which any
     * RFC-conform <i>value</i> range proposed by the iSCSI initiator must fall.
     */
    private final NumericalValueRange protocolValueRange;

    /**
     * This value will be the negotiation result, if it falls into the
     * <i>value</i> range proposed by the iSCSI initiator.
     */
    private final int negotiationValue;

    /**
     * The {@link NumericalRangeEntry} constructor.
     * 
     * @param keySet
     *            contains all relevant keys
     * @param use
     *            determines under which circumstances the parameter may be
     *            negotiated
     * @param negotiationStatus
     *            indicates whether there is a default value or if the parameter
     *            must be negotiated
     * @param negotiationValue
     *            the value the jSCSI Target would like to use
     * @param protocolValueRange
     *            specifies the boundaries into which any RFC-conform
     *            <i>value</i> range proposed by the iSCSI initiator must fall
     * @param defaultValue
     *            the default value or <code>null</code>
     */
    public NumericalRangeEntry(final KeySet keySet, final Use use, final NegotiationStatus negotiationStatus,
        final int negotiationValue, final NumericalValueRange protocolValueRange, final Object defaultValue) {
        super(keySet, NegotiationType.NEGOTIATED, use, negotiationStatus, defaultValue);
        this.negotiationValue = negotiationValue;
        this.protocolValueRange = protocolValueRange;
    }

    @Override
    protected boolean inProtocolValueRange(Object values) {
        // receives a NumericalValueRange
        return protocolValueRange.contains((NumericalValueRange)values);
    }

    @Override
    protected Object parseOffer(TargetServer target, String values) {
        // expected format: "1234~5678"

        NumericalValueRange range = NumericalValueRange.parseNumericalValueRange(values);
        if (range == null && target.getConfig().getAllowSloppyNegotiation()) {
            /*
             * The format was violated.
             * 
             * The jSCSI Initiator sends "IFMarkInt=2048" and "OFMarkInt=2048",
             * not ranges.
             * 
             * If values is at least a number we will fix this.
             */
            final SingleNumericalValue singleValue = SingleNumericalValue.parseSingleNumericValue(values);
            if (singleValue != null) {
                range = NumericalValueRange.create(singleValue.getValue(),// min
                    singleValue.getValue());// max
            }
        }

        return range;
    }

    @Override
    protected void processDeclaration(Object values) {
        // there are no declarations, see constructor
    }

    @Override
    protected String processNegotiation(Object values) {
        // receives a NumericalValueRange
        final NumericalValueRange range = (NumericalValueRange)values;
        // accept if negotiatedValue in initiator offer, else reject
        if (range.contains(negotiationValue)) {
            value = negotiationValue;
            return value.toString();
        } // else
        value = null;
        return null;
    }

    @Override
    public Integer getIntegerValue() {
        return (Integer)value;
    }

    @Override
    public Entry copy() {
        final NumericalRangeEntry e =
            new NumericalRangeEntry(keySet, use, negotiationStatus, negotiationValue, protocolValueRange,
                (Integer)value);
        e.alreadyNegotiated = this.alreadyNegotiated;
        return e;
    }
}