/*
    * Copyright (c) 1998-2002 The Jgroup Team.
    *
    * This program is free software; you can redistribute it and/or modify
    * it under the terms of the GNU Lesser General Public License version 2 as
    * published by the Free Software Foundation.
    *
    * 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 Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   *
   */
  
  package jgroup.relacs.types;
  
  import java.io.Externalizable;
  import java.io.IOException;
  import java.io.ObjectInput;
  import java.io.ObjectOutput;
  import java.util.HashSet;
  import java.util.Set;
  
  import jgroup.core.MemberId;
  import jgroup.core.View;
  
  
  /**
   *  This class implements the <code>jgroup.core.View</code> interface.
   *
   *  @author Alberto Montresor
   *  @author Hein Meling
   *  @since Jgroup 0.1
   */
  public class ViewImpl
    implements View, Externalizable
  {
  
    private static final long serialVersionUID = 5806351416950303803L;
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Fields
    ////////////////////////////////////////////////////////////////////////////////////////////
  
    /** Group identifier */
    private int gid;
    
    /** View identifier (unique and increasing for each new view) */
    private long vid;
  
    /** The number of views merging into this one */
    private int mergingViews;
  
    /** View composition */
    private MemberId[] members;
  
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Constructors
    ////////////////////////////////////////////////////////////////////////////////////////////
  
    /**
     *  Default constructor for externalization
     */
    public ViewImpl() { }
  
    /**
     * Creates a view that contains no members; this kind of view is
     * used only to detect group failures (failure of a single last member).
     */
    public ViewImpl(int gid)
    {
      this.gid = gid;
      this.vid = 0;
      this.mergingViews = 0;
      members  = new MemberId[0];
    }
  
    /**
     * Creates a view composed by a single member and a single host; used
     * to initialize members joining to a group.
     */
    public ViewImpl(int gid, long vid, MemberId me)
    {
      this.gid     = gid;
      this.vid     = vid;
      this.mergingViews = 0;
      members = new MemberId[1];
      members[0] = me;
    }
  
    /**
     * Creates a view composed by a set of hosts and members; used to create
     * new view after receiving view messages.
     * 
    * @param mergingViews 
    *   The number of views merging into this one.
    */
   public ViewImpl(int gid, long vid, int mergingViews, MemberId[] members)
   {
     this.gid     = gid;
     this.vid     = vid;
     this.mergingViews = mergingViews;
     this.members = members;
   }
 
   /**
    * Clones a view.
    */
   public ViewImpl(View v)
   {
     this.gid     = v.getGid();
     this.vid     = v.getVid();
     this.mergingViews = v.mergingViews();
     this.members = v.getMembers();
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // View interface methods
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    *  Returns the identifier of the group for which this view has been
    *  generated.
    */
   public int getGid()
   {
     return gid;
   }
 
 
   /**
    *  Returns the identifier of this view
    */
   public long getVid()
   {
     return vid;
   }
 
   /**
    *  Returns the number of views (or partitions) merging into this view.
    */
   public int mergingViews()
   {
     return mergingViews;
   }
 
   /**
    *  Returns an array of <code>MemberId</code>s identifying the members
    *  included in this view.
    */
   public MemberId[] getMembers()
   {
     return members.clone();
   }
 
   /* (non-Javadoc)
    * @see jgroup.core.View#getLeader()
    */
   public MemberId getLeader()
   {
     return members[0];
   }
 
   /* (non-Javadoc)
    * @see jgroup.core.View#isLeader(jgroup.core.MemberId)
    */
   public boolean isLeader(MemberId member)
   {
     /* If there is only one member, it is the leader. */
     return members.length == 1 || member.equals(members[0]);
   }
 
   /* (non-Javadoc)
    * @see jgroup.core.View#commonMembers(jgroup.core.MemberId[])
    */
   public MemberId[] commonMembers(MemberId[] otherMembers)
   {
     if (otherMembers == null)
       return getMembers();
     Set<MemberId> commonMembers = new HashSet<MemberId>();
     for (int i = 0; i < members.length; i++)
       for (int j = 0; j < otherMembers.length; j++)
         if (members[i].equals(otherMembers[j]))
           commonMembers.add(members[i]);
     return (MemberId[]) commonMembers.toArray(new MemberId[commonMembers.size()]);
   }
 
   /* (non-Javadoc)
    * @see jgroup.core.View#commonMembers(jgroup.core.View)
    */
   public MemberId[] commonMembers(View view)
   {
     if (this.equals(view))
       return getMembers();
     return commonMembers(((ViewImpl) view).members);
   }
 
   /* (non-Javadoc)
    * @see jgroup.core.View#newMembers(jgroup.core.View)
    */
   public MemberId[] newMembers(View previousView)
   {
     if (previousView == null)
       return getMembers();
     if (this.equals(previousView))
       return new MemberId[0];
     Set<MemberId> newMembers = new HashSet<MemberId>();
     MemberId[] previousMembers = previousView.getMembers();
     for (int i = 0; i < members.length; i++) {
       boolean found = false;
       for (int j = 0; !found && j < previousMembers.length; j++) {
         if (members[i].equals(previousMembers[j])) {
           found = true;
         }
       }
       if (!found)
         newMembers.add(members[i]);
     }
     return (MemberId[]) newMembers.toArray(new MemberId[newMembers.size()]);
   }
 
   /* (non-Javadoc)
    * @see jgroup.core.View#oldMembers(jgroup.core.View)
    */
   public MemberId[] oldMembers(View previousView)
   {
     if (previousView == null) {
       // There are no old members, since the previous view is null
       return new MemberId[0];
     }
     // This is the reverse case of newMembers()
     return previousView.newMembers(this);
   }
 
   /* (non-Javadoc)
    *  @see jgroup.core.View#contains(jgroup.core.MemberId)
    */
   public boolean contains(MemberId memberId)
   {
     boolean found = false;
     for (int i = 0; !found && i < members.length; i++) {
       found = members[i].equals(memberId);
     }
     return found;
   }
   
 
   /* (non-Javadoc)
    * @see jgroup.core.View#containsAll(jgroup.core.View)
    */
   public boolean containsAll(View view)
   {
     if (view == null)
       return false;
     // This is to avoid cloning, when using getMembers()
     MemberId[] viewMembers = ((ViewImpl) view).members;
     /*
      * Check if the current view contains all members of the
      * new view.
      */ 
     for (int i = 0; i < viewMembers.length; i++) {
       if (!contains(viewMembers[i])) {
         return false;
       }
     }
     return true;
   }
 
 
   /* (non-Javadoc)
    * @see jgroup.core.View#hasSameMembers(jgroup.core.View)
    */
   public boolean hasSameMembers(View prevView)
   {
     if (prevView == null || this.size() != prevView.size())
       return false;
     MemberId[] commonMembers = this.commonMembers(prevView);
     if (commonMembers.length != prevView.size())
       return false;
     else
       return true;
   }
 
 
   /**
    *  Returns the number of members in this view.
    */
   public int size()
   {
     return members.length;
   }
 
 
   /* (non-Javadoc)
    * @see jgroup.core.View#getMemberPosition(jgroup.core.MemberId)
    */
   public int getMemberPosition(MemberId id)
   {
     for (int i = 0; i < members.length; i++)
       if (members[i].equals(id))
         return i;
     return -1;
   }
 
 
   /**
    *  Returns true if the specified member is the member at the given
    *  position; otherwise false is returned.
    *
    *  @param pos
    *    The position in the view to check for equality with the given
    *    member.  A negative position value is considered to indicate
    *    a position from the end of the view array, while a positive
    *    value indicate a position from the beginning of the view
    *    array.  A position value outside the range of the view, will
    *    always return false.
    *  @param member
    *    The member whose position to check.
    *  @return 
    *    True if the given member is at the specified position in this
    *    view; false otherwise.
    */
   public boolean memberHasPosition(int pos, MemberId member)
   {
     /* A negative position runs from the end of the array. */
     if (pos < 0)
       pos = members.length + pos;
 
     /* Check if the given (or computed) position is possible. */
     if (pos >= 0 && pos < members.length)
       return members[pos].equals(member);
     else 
       return false;
   }
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Methods from Object
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    *  Compares two <code>View</code>s for content equality.
    *
    *  @param obj the Object to compare with
    *  @return  true if these Objects are equal; false otherwise.
    */
   public boolean equals(Object obj)
   {
     if (obj == null)
       return false;
     if (obj == this)
       return true;
     if (obj instanceof ViewImpl) {
       ViewImpl view = (ViewImpl) obj;
       return (gid == view.gid && vid == view.vid);
     }
     return false;
   }
 
 
   /**
    *  Prints the content of this view.
    */
   public String toString()
   {
     StringBuilder buf = new StringBuilder("\n  [GroupId: ");
     buf.append(gid);
     buf.append(", ViewId: ");
     buf.append(vid);
     buf.append(", Partitions: ");
     buf.append(mergingViews);
     buf.append("]\n  ");
     for (int i = 0; i < members.length; i++) {
       buf.append(members[i]);
       if (i == 0)
         buf.append(" [leader]\n  ");
       else
         buf.append("\n  ");
     }
     return buf.toString();
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Methods from Externalizable
   ////////////////////////////////////////////////////////////////////////////////////////////
   
   /**
    *  Restores the content of this object from the marshalled data contained
    *  in the specified input stream.
    * 
    *  @param in the stream to be read
    */
   public void readExternal(ObjectInput in)
     throws IOException, ClassNotFoundException
   {
     gid = GroupId.unmarshal(in);
     vid = ViewId.unmarshal(in);
     mergingViews = in.readInt();
     int len = GroupIndex.unmarshal(in);
     members = new MemberId[len];
     for (int i=0; i < len; i++) {
       members[i] = new MemberIdImpl();
       members[i].readExternal(in);
     }
   }
 
   /**
    *  Marshals the content of this object to the specified output stream.
    * 
    *  @param out the stream to be written
    */
   public void writeExternal(ObjectOutput out)
     throws IOException
   {
     GroupId.marshal(out, gid);
     ViewId.marshal(out, vid);
     out.writeInt(mergingViews);
     GroupIndex.marshal(out, members.length);
     for (int i=0; i < members.length; i++) {
       members[i].writeExternal(out);
     }
   }
   
   public Object clone()
   {
     ViewImpl v = new ViewImpl();
     v.gid = gid;
     v.vid = vid;
     v.members = members.clone();
     v.mergingViews = mergingViews;
     return v;    
   }
 
 } // END ViewImpl