/*
 * Created on Oct 30, 2005
 * Created by Joseph Bridgewater
 * Copyright (C) 2005, 2006 Aelitis, All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * This program 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 for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 * 
 * AELITIS, SAS au capital de 46,603.30 euros
 * 8 Allee Lenotre, La Grille Royale, 78600 Le Mesnil le Roi, France.
 *
 */

package com.aelitis.azureus.core.peermanager.piecepicker.util;

import java.util.Arrays;

import com.aelitis.azureus.core.util.HashCodeUtils;

/**
 * @author MjrTom
 * A fairly light-weight, versatile boolean array of bit flags with administrative fields and methods
 * Originaly designed as a boolean array to correspond to the pieces in a torrent,
 * for example to show which pieces are; downloading, high priority, rarest, available, or whatever.
 * This class is subject to experimentation, although the important uses of the class must NOT be broken.
 */
public class BitFlags
    implements Cloneable
{
	// These are public so they can be read quickly.
    // Please don't try to modify them outside of the given methods.
    /** Index of first set bit */
    public int          start;
    /** Index of last set bit */
    public int          end;
    /** how many bits are set */
	public int			nbSet;
    /** The array of bit flags */
	public final boolean[]	flags;
	
	public BitFlags(final int count)
	{
        start =count;
        end =0;
        nbSet =0;
		flags =new boolean[count];
	}

	public BitFlags(final boolean[]	_flags )
	{
        start =_flags.length;
		flags	= _flags;
		for (int i=0;i<flags.length;i++){
			if ( flags[i]){
				nbSet++;
				if ( i < start ){
					start = i;
				}
				end	= i;
			}
		}
	}
    
    /** clone constructor */
    public BitFlags(final BitFlags other)
    {
        start =other.start;
        end =other.end;
        nbSet =other.nbSet;
        flags =(boolean[])other.flags.clone();
    }

    public Object clone()
    {
        return new BitFlags(this);
    }
    
    public int hashCode()
    {
        int result =HashCodeUtils.hashMore(0, flags);
        result =HashCodeUtils.hashMore(result, nbSet);
        result =HashCodeUtils.hashMore(result, end);
        return HashCodeUtils.hashMore(result, start);
    }
    
    public boolean equals(Object o)
    {
        if (o ==null ||!(o instanceof BitFlags))
            return false;
        final BitFlags other =(BitFlags) o;
        if (this.start !=other.start)
            return false;
        if (this.end !=other.end)
            return false;
        if (this.nbSet !=other.nbSet)
            return false;
        if (this.flags ==null &&other.flags ==null)
            return true;
        if (this.flags ==null ||other.flags ==null)
            return false;
        if (this.flags.length !=other.flags.length)
            return false;
        for (int i =0; i <this.flags.length; i++)
        {
            if (this.flags[i] ^ other.flags[i])
                return false;
        }

        return true;
    }
    
    /** You can read flags.length instead (but please don't modify it)
     * @return the number of elements in this array
     */
    public int size()
    {
        return flags.length;
    }
    
	public void clear()
	{
		Arrays.fill(flags, false);
		start =flags.length;
		end =0;
		nbSet =0;
	}

    /** for setting a flag that is already known to be the first true flag */ 
	public void setStart(final int i)
	{
		flags[i] =true;
		nbSet++;
		start =i;
	}

    /** for setting a flag that is not known to be the first or last, or not */ 
	public void set(final int i)
	{
		if (!flags[i])
		{
			flags[i] =true;
			nbSet++;
			if (start >i)
				start =i;
			if (end <i)
				end =i;
		}
	}

    /** this is for setting a flag that is already known to be the last true flag */ 
	public void setEnd(final int i)
	{
		flags[i] =true;
		nbSet++;
		end =i;
	}
	
    /** clears the array then sets the given flag */ 
	public void setOnly(final int i)
	{
        if (start <flags.length)
            Arrays.fill(flags, start, end, false);
		nbSet =1;
		start =i;
		end =i;
		flags[i] =true;
	}
	
	public void setAll()
	{
		start =0;
		end =flags.length -1;
		Arrays.fill(flags, start, end, true);
		nbSet =flags.length;
	}
	
	/**
	 * Experimental.  Returns a new BitFlags with flags set as the logical AND of both BitFlags.
     * The length of both must be the same.
	 * @param other BitFlags to be ANDed with this BitFlags. Must not be null.
	 * @return new BitFlags representing the logical AND of the two
	 */
	public BitFlags and(final BitFlags other)
	{
		final BitFlags result =new BitFlags(flags.length);
		if (this.nbSet >0 &&other.nbSet >0)
		{
            // setup outer union bounds
			int i =this.start >other.start ?this.start :other.start;
			final int endI =this.end <other.end ?this.end :other.end;
            // find the first common set bit
			for (; i <=endI; i++)
			{
				if (this.flags[i] &&other.flags[i])
				{
                    result.flags[i] =true;
                    result.nbSet++;
                    result.start =i;
					break;
				}
			}
            // find any remaining common bits
			for (; i <=endI; i++)
			{
				if (this.flags[i] &&other.flags[i])
				{
                    result.flags[i] =true;
                    result.nbSet++;
                    result.end =i;
				}
			}
            if (result.end <result.start)
                result.end =result.start;
		}
		return result;
	}

}
