/*-
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 2002, 2010 Oracle and/or its affiliates.  All rights reserved.
 *
 * $Id$
 */

package com.sleepycat.db;

import com.sleepycat.db.internal.Db;
import com.sleepycat.db.internal.DbConstants;
import com.sleepycat.db.internal.DbSequence;
import com.sleepycat.db.internal.DbTxn;

/**
Specify the attributes of a sequence.
*/
public class SequenceConfig implements Cloneable {
    /*
     * For internal use, final to allow null as a valid value for
     * the config parameter.
     */
    /**
    Default configuration used if null is passed to methods that create a
    cursor.
    */
    public static final SequenceConfig DEFAULT = new SequenceConfig();

    /* package */
    static SequenceConfig checkNull(SequenceConfig config) {
        return (config == null) ? DEFAULT : config;
    }

    /* Parameters */
    private int cacheSize = 0;
    private long rangeMin = Long.MIN_VALUE;
    private long rangeMax = Long.MAX_VALUE;
    private long initialValue = 0L;

    /* Flags */
    private boolean allowCreate = false;
    private boolean decrement = false;
    private boolean exclusiveCreate = false;
    private boolean autoCommitNoSync = false;
    private boolean wrap = false;

    /**
    An instance created using the default constructor is initialized with
    the system's default settings.
    */
    public SequenceConfig() {
    }

    /**
Configure the {@link com.sleepycat.db.Database#openSequence Database.openSequence} method to
    create the sequence if it does not already exist.
<p>
This method may be called at any time during the life of the application.
<p>
@param allowCreate
If true,
configure the {@link com.sleepycat.db.Database#openSequence Database.openSequence} method to
    create the sequence if it does not already exist.
    */
    public void setAllowCreate(final boolean allowCreate) {
        this.allowCreate = allowCreate;
    }

    /**
Return true if the {@link com.sleepycat.db.Database#openSequence Database.openSequence} method is configured
    to create the sequence if it does not already exist.
<p>
This method may be called at any time during the life of the application.
<p>
@return
True if the {@link com.sleepycat.db.Database#openSequence Database.openSequence} method is configured
    to create the sequence if it does not already exist.
    */
    public boolean getAllowCreate() {
        return allowCreate;
    }

    /**
Set the
Configure the number of elements cached by a sequence handle.
<p>
This method may be called at any time during the life of the application.
<p>
@param cacheSize
The Configure the number of elements cached by a sequence handle.
    */
    public void setCacheSize(final int cacheSize) {
        this.cacheSize = cacheSize;
    }

    /**
Return the number of elements cached by a sequence handle..
<p>
This method may be called at any time during the life of the application.
<p>
@return
The number of elements cached by a sequence handle..
    */
    public int getCacheSize() {
        return cacheSize;
    }

    /**
Specify that the sequence should be decremented.
<p>
This method may be called at any time during the life of the application.
<p>
@param decrement
If true,
specify that the sequence should be decremented.
    */
    public void setDecrement(boolean decrement) {
        this.decrement = decrement;
    }

    /**
Return true if the sequence is configured to decrement.
<p>
This method may be called at any time during the life of the application.
<p>
@return
True if the sequence is configured to decrement.
    */
    public boolean getDecrement() {
         return decrement;
    }

    /**
Configure the {@link com.sleepycat.db.Database#openSequence Database.openSequence} method to
    fail if the database already exists.
<p>
This method may be called at any time during the life of the application.
<p>
@param exclusiveCreate
If true,
configure the {@link com.sleepycat.db.Database#openSequence Database.openSequence} method to
    fail if the database already exists.
    */
    public void setExclusiveCreate(final boolean exclusiveCreate) {
        this.exclusiveCreate = exclusiveCreate;
    }

    /**
Return true if the {@link com.sleepycat.db.Database#openSequence Database.openSequence} method is configured to
    fail if the database already exists.
<p>
This method may be called at any time during the life of the application.
<p>
@return
True if the {@link com.sleepycat.db.Database#openSequence Database.openSequence} method is configured to
    fail if the database already exists.
    */
    public boolean getExclusiveCreate() {
        return exclusiveCreate;
    }

    /**
Set the
Set the initial value for a sequence.
<p>This call is only
    effective when the sequence is being created.
<p>
This method may be called at any time during the life of the application.
<p>
@param initialValue
The Set the initial value for a sequence.
    */
    public void setInitialValue(long initialValue) {
        this.initialValue = initialValue;
    }

    /**
Return the initial value for a sequence..
<p>
This method may be called at any time during the life of the application.
<p>
@return
The initial value for a sequence..
    */
    public long getInitialValue() {
        return initialValue;
    }

    /**
Configure auto-commit operations on the sequence to not flush
    the transaction log.
<p>
This method may be called at any time during the life of the application.
<p>
@param autoCommitNoSync
If true,
configure auto-commit operations on the sequence to not flush
    the transaction log.
    */
    public void setAutoCommitNoSync(final boolean autoCommitNoSync) {
        this.autoCommitNoSync = autoCommitNoSync;
    }

    /**
Return true if the auto-commit operations on the sequence are configure to not
    flush the transaction log..
<p>
This method may be called at any time during the life of the application.
<p>
@return
True if the auto-commit operations on the sequence are configure to not
    flush the transaction log..
    */
    public boolean getAutoCommitNoSync() {
        return autoCommitNoSync;
    }

    /**
    Configure a sequence range.  This call is only effective when the
    sequence is being created.
    <p>
    @param min
    The minimum value for the sequence.
    @param max
    The maximum value for the sequence.
    */
    public void setRange(final long min, final long max) {
        this.rangeMin = min;
        this.rangeMax = max;
    }

    /**
Return the minimum value for the sequence.
<p>
This method may be called at any time during the life of the application.
<p>
@return
The minimum value for the sequence.
    */
    public long getRangeMin() {
        return rangeMin;
    }

    /**
Return the maximum value for the sequence.
<p>
This method may be called at any time during the life of the application.
<p>
@return
The maximum value for the sequence.
    */
    public long getRangeMax() {
        return rangeMax;
    }

    /**
Specify that the sequence should wrap around when it is
    incremented (decremented) past the specified maximum (minimum) value.
<p>
This method may be called at any time during the life of the application.
<p>
@param wrap
If true,
specify that the sequence should wrap around when it is
    incremented (decremented) past the specified maximum (minimum) value.
    */
    public void setWrap(final boolean wrap) {
        this.wrap = wrap;
    }

    /**
Return true if the sequence will wrap around when it is incremented
    (decremented) past the specified maximum (minimum) value.
<p>
This method may be called at any time during the life of the application.
<p>
@return
True if the sequence will wrap around when it is incremented
    (decremented) past the specified maximum (minimum) value.
    */
    public boolean getWrap() {
        return wrap;
    }

    /* package */
    DbSequence createSequence(final Db db)
        throws DatabaseException {

        int createFlags = 0;

        return new DbSequence(db, createFlags);
    }

    /* package */
    DbSequence openSequence(final Db db,
                    final DbTxn txn,
                    final DatabaseEntry key)
        throws DatabaseException {

        final DbSequence seq = createSequence(db);
        // The DB_THREAD flag is inherited from the database
        boolean threaded = ((db.get_open_flags() & DbConstants.DB_THREAD) != 0);

        int openFlags = 0;
        openFlags |= allowCreate ? DbConstants.DB_CREATE : 0;
        openFlags |= exclusiveCreate ? DbConstants.DB_EXCL : 0;
        openFlags |= threaded ? DbConstants.DB_THREAD : 0;

        if (db.get_transactional() && txn == null)
            openFlags |= DbConstants.DB_AUTO_COMMIT;

        configureSequence(seq, DEFAULT);
        boolean succeeded = false;
        try {
            seq.open(txn, key, openFlags);
            succeeded = true;
            return seq;
        } finally {
            if (!succeeded)
                try {
                    seq.close(0);
                } catch (Throwable t) {
                    // Ignore it -- an exception is already in flight.
                }
        }
    }

    /* package */
    void configureSequence(final DbSequence seq, final SequenceConfig oldConfig)
        throws DatabaseException {

        int seqFlags = 0;
        seqFlags |= decrement ? DbConstants.DB_SEQ_DEC : DbConstants.DB_SEQ_INC;
        seqFlags |= wrap ? DbConstants.DB_SEQ_WRAP : 0;

        if (seqFlags != 0)
            seq.set_flags(seqFlags);

        if (rangeMin != oldConfig.rangeMin || rangeMax != oldConfig.rangeMax)
            seq.set_range(rangeMin, rangeMax);

        if (initialValue != oldConfig.initialValue)
            seq.initial_value(initialValue);

        if (cacheSize != oldConfig.cacheSize)
            seq.set_cachesize(cacheSize);
    }

    /* package */
    SequenceConfig(final DbSequence seq)
        throws DatabaseException {

        // XXX: can't get open flags
        final int openFlags = 0;
        allowCreate = (openFlags & DbConstants.DB_CREATE) != 0;
        exclusiveCreate = (openFlags & DbConstants.DB_EXCL) != 0;

        final int seqFlags = seq.get_flags();
        decrement = (seqFlags & DbConstants.DB_SEQ_DEC) != 0;
        wrap = (seqFlags & DbConstants.DB_SEQ_WRAP) != 0;

        // XXX: can't get initial value
        final long initialValue = 0;

        cacheSize = seq.get_cachesize();

        rangeMin = seq.get_range_min();
        rangeMax = seq.get_range_max();
    }
}