public class Node
        {
                int nodeNo;
                boolean active=false;
                int nextActiveTime=0; // minute;
                ArrayList <String>pieces=new ArrayList<String>();
                int curActiveTime=0; // how many minute I left;
                Random r = new Random();
                int nodeSpeed=2; // mb/Min
                
                
                StaticsSimulator staticx=null;
                public Node(StaticsSimulator x)
                {
                        staticx=x;
                        this.nodeSpeed = x.nodeSpeed;
                }
                
                /**
                 * initialize my active time/status
                 */
                public void init() {
                        nextActiveTime = r.nextInt(avgSleepTime);
                }

                public ArrayList<String> getPieces()
                {
                        return pieces;
                }
                
                public void tick()
                {
                        nextActiveTime-=1;
                        curActiveTime-=1;
                        updateStatus();
                        if (active && pieces.size()<1)
                                System.out.println("What ?! I am empty:" + pieces.size());
                        
                }
                
                public void updateStatus()
                {
                        double rx = r.nextDouble();
                        if (rx<staticx.nodeCrashRate)
                        {
                                forceDeActiveX();
                                if (active)
                                        forceDeActive();
                                // node crashed.
                                pieces.clear();
                                staticx.failNodeCnt++;
                                active=false;
                                calcNextActive();
                                return;
                        }
                                
                        if (curActiveTime==0){
                                active=false;
                                forceDeActive();
                        }else
                        if (nextActiveTime==0){
                                forceActive();
                        }
                        
                        if (active)
                        {
                                // check my pieces. purge too onLineHealth pieces
                                // get less healthy pieces from other peer.
                                for (int i=0; i< nodeSpeed;i++)
                                {
                                        String myMostHealthPiece = "";
                                        if (pieces.size() >=nodeCapability){
                                                myMostHealthPiece=getMyMostHealthPiece();
                                                
                                                // don't do anything if my piece is too unhealthy.
                                                PieceHealth ph = totalPieces.get(myMostHealthPiece);
                                                if (ph.getGlobalHealth()<=1){
                                                        myMostHealthPiece="";
                                                        continue;
                                                }
                                                
                                        }
                                        String leastHealthPiece=staticx.getLeastHealthPiece(pieces);
                                        
        
                                        if (leastHealthPiece!=null && leastHealthPiece.length()>0){
                                                if (myMostHealthPiece!=""){
                                                        if (pieces.size()>=nodeCapability){
                                                                pieces.remove(myMostHealthPiece);
                                                                staticx.unRegPiece(myMostHealthPiece);
                                                                staticx.delPiece(myMostHealthPiece);
                                                        }
                                                }
                                                pieces.add(leastHealthPiece);
                                                staticx.regPiece(leastHealthPiece);
                                                staticx.addPiece(leastHealthPiece);
                                                
                                        }else
                                        {
                                                System.out.println("XD. no Least Health Piece exists ?");
                                        }
                                }
                                
                        }
                }
                
                /**
                 * 
                 * @return
                 */
                private String getMyMostHealthPiece() {
                        String ret="";
                        int health=-1;
                        for (String x:pieces)
                        {
                                PieceHealth ph=staticx.totalPieces.get(x);
                                if (ph.getOnLineHealth()>health)
                                {
                                        ret = x;
                                        health=ph.getOnLineHealth();
                                }
                        }
                        return ret;
                }

                
                private void forceDeActiveX()
                {
                        for (String i:pieces)
                        {
                                staticx.delPiece(i);
                        }
                }
                
                private void forceDeActive() {
                        for (String i:pieces)
                        {
                                staticx.unRegPiece(i);
                        }
                }
                


                /**
                 * 
                 * @param pieceNo
                 * @return -1 = no removal.
                 */
                public String addPiece(String pieceNo)
                {
                        String removed="";
                        if (pieces.size()>= nodeCapability)
                        {
                                removed=pieces.remove(0);
                        }
                        pieces.add(pieceNo);
                        
                        return removed;
                }
                
                public void forceActive()
                {
                        active=true;
                        calcNextActive();
                        calcCurActive();
                        // register my pieces
                        for (String i:pieces)
                        {
                                staticx.regPiece(i);
                        }
                }
                
                public void calcNextActive()
                {
                        
                        while (nextActiveTime <=0){
                                double d=r.nextGaussian();
                                nextActiveTime = avgSleepTime + (int)(d*avgSleepTime/4);
                        }
                }
                
                public void calcCurActive()
                {
                        double d=r.nextGaussian();
                        curActiveTime = activeDuration + (int)(d*activeDuration/4);
                }
                
                public boolean isActive()
                {
                        return active;
                }
                
                @Override
                public String toString()
                {
                        StringBuffer sb = new StringBuffer();
                        sb.append("Active:" + active);
                        sb.append("\nPieces:");
                        for (String pie:pieces)
                        {
                                sb.append(pie + "\t");
                        }
                        sb.append("\n");
                        return sb.toString();
                }
        }