Node.java

import java.sql.Timestamp;
import java.util.LinkedList;
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;

public class Node{

	private boolean type; //type true for fast nodes and false for lazy nodes
	private String uID;
	private float currOwned;
	private Timestamp creationTime;

	//For the next set of events to executed by the node
	Timestamp nextTxnTime;
	Timestamp nextBlockTime;

	List<Transaction> allTxns = new ArrayList<Transaction>();
//	List<Transaction> testTxn = new ArrayList<Transaction>(); 


	LinkedList<Transaction> txnIncludePending  = new LinkedList<Transaction>();
	int numTxnIncludePending = 0;

	LinkedList<Transaction> totalTxnIncludePending = new LinkedList<Transaction>();
	int numTotalTxnIncludePending = 0;

	LinkedList<Block> blockIncludePending = new LinkedList<Block>();
	int numBlockIncludedPending = 0;

	//Varialbes to store information about longest chain received so far
	Block probParentBlock;

	//Transaction details
	ArrayList<Transaction> receivedTxn = new ArrayList<Transaction>();

	int numReceivedTxn = 0;
	
	ArrayList<Transaction> sentTxn = new ArrayList<Transaction>();
	int numSentTxn = 0;

	//Connection Details
	LinkedList<Node> connectedNode = new LinkedList<Node>();
	
	int numConnection = 0;
	int numCreatedBlock = 0; //Number of block generated by this node so far

	//Tree to store all the blocks heard by the Node so far
	HashMap<String, Block> blockChain = new HashMap<String, Block>();

	//HashMap to store all the transactions forwarded by the node.
	HashMap<String, Boolean> forwardedMessage = new HashMap<String, Boolean>();
	
	public final static String GOD_ID = "god"; 

	//Default constructor
	Node(String uID, boolean type, Timestamp creationTime, Block genesisBlock){
		this.uID = uID;
		this.type = type;
		this.creationTime = creationTime;
		this.currOwned = 50;
		this.probParentBlock = genesisBlock;
		blockChain.put(genesisBlock.getBlockID(),genesisBlock);
	}

	//function to gerate block at a particular timestamp
	public Block generateBlock(Block parentBlock, Timestamp creationTime, int mainDiff, int subDiff){
		String uBlockID = uID + "_B_" + numCreatedBlock;
		this.nextBlockTime = creationTime;
		this.probParentBlock = parentBlock;
		this.calculateBTC();
		Block newBlock = new Block(uBlockID, creationTime, uID, parentBlock, null);
		
		ProofWork powProof = new ProofWork();
		//powProof.setMainDiff(mainDiff);
		//powProof.setSubDiff(subDiff);
		powProof.setMainDiff(1);
		powProof.setSubDiff(0);
		newBlock.setProof(powProof);
		
		return newBlock;
	}

	//Code to add a block in the node's block chain
	public boolean addBlock(Block newBlock){
		long startMining= System.currentTimeMillis();
		System.out.println("\nstart Mining at: " + startMining);
		newBlock.mineBlock();
		System.out.println("Mining time: " + (System.currentTimeMillis() - startMining));		
	
		//check if all txns in the block valid according to me
		boolean valid = true;
		ArrayList<Transaction> tmpTxns = newBlock.getTxnList();
		for(int i=0;i<tmpTxns.size();i++){
			Transaction tmpTxn = tmpTxns.get(i);
			//check transaction validity
			if(!this.checkValid(tmpTxn)){
				valid = false;
				break;
			}
		}
		//end of check
		
		String parentBlockID = newBlock.getParentBlockID();
		String currentBlockID = newBlock.getBlockID();
		String creatorID = newBlock.getCreatorID();
		if(blockChain.containsKey(parentBlockID) && valid){
			blockChain.put(currentBlockID, newBlock);
			if(!blockChain.get(parentBlockID).checkChild(currentBlockID)){
				blockChain.get(parentBlockID).putChild(currentBlockID);
				if(this.uID.equals(creatorID)){
					numCreatedBlock++;
				}
				
				return true;
			}
		}else{
			//block can turn valid lateron
			if(!this.blockIncludePending.contains(newBlock)){
				this.blockIncludePending.add(newBlock);
			}
		}
		return false;
	}
	
	//adds pending blocks to the block chain
	public void addPendingBlocks(){ 
		int num_new = 1;
		while(num_new>0){
			num_new = 0;
			for(int i=0;i<this.blockIncludePending.size();i++) { // Note: pending list for blocks needs to be stored and loaded
				if(this.addBlock(this.blockIncludePending.get(i))){ // Note: assume now, it is loaded from DB
					num_new++;
				}
			}
		}
	}
	
	// adding pending transaction to the new block
	public void addPendingTx2NewBlock(Block newBlock) {
		//mining fee transaction 
		Transaction mfee = new Transaction(getUID()+"_mining_fee", Node.GOD_ID, getUID(), 50, new Timestamp(System.currentTimeMillis()));

		newBlock.addTxn(mfee); // adding mining fee at the current transaction in array list of current block
		System.out.println("new block minined successfully, 50 coins rewards at time: " +System.currentTimeMillis());
		
		//change block to include transactions
		Block parent = probParentBlock;
		
		for(int i=0;i<allTxns.size(); i++) { // verify all Txns
			boolean alreadyIncluded = false;
			Transaction tmpTxn = allTxns.get(i);
			
			//check block validity
			if(!checkValid(tmpTxn)){
				continue;	//continue if invalid. It can turn valid after some time.
			}
			while(parent!=null){ // controlling double spending
				if(parent.txnList.contains(tmpTxn)){
					alreadyIncluded = true;
					break;
				}
				parent = parent.getParentBlock();
			}
			if(!alreadyIncluded) {
//				long beginAdd = System.currentTimeMillis();
				newBlock.addTxn(tmpTxn); 
//				System.out.println("add Txns time interval: " + String.valueOf(System.currentTimeMillis() - beginAdd));
			}
		}
	}

	public LinkedList<Transaction> getTxnIncludePending(){
		return this.txnIncludePending;
	}
	
	//function to generate a transaction
	Transaction generateTxn(String receiverID, float txnAmount, Timestamp txnTime){
		String txnID = uID + "_" + numSentTxn;
		Transaction newTxn = new Transaction(txnID, uID, receiverID, txnAmount, txnTime);
		return newTxn;
	}
	
	//function to add a new transaction to a node
	boolean addTxn(Transaction newTxn) {
		if(newTxn.getSenderID().equals(this.uID)){			
			if(newTxn.getAmount()<=currOwned){
				//Add to sentTxn ArrayList
				sentTxn.add(numSentTxn, newTxn);
				numSentTxn++;
				this.numTotalTxnIncludePending++;
				this.totalTxnIncludePending.add(newTxn);
				return true;
			} else {
				return false;
			}
			
		} else if(newTxn.getReceiverID().equals(this.uID)){
			//Add to receivedTxn ArrayList
			receivedTxn.add(numReceivedTxn, newTxn);
			numReceivedTxn++;
			this.numTotalTxnIncludePending++;
			this.totalTxnIncludePending.add(newTxn);
			return true;
		} else {
			this.numTotalTxnIncludePending++;
			this.totalTxnIncludePending.add(newTxn);
			return true;
		}
	}

	//check if txn is valid or not (Proof of work is conducted here)
	public boolean checkValid(Transaction t){
		String senderID = t.getSenderID();
		
		if(senderID == GOD_ID ){
			return true;
		}
		
		return (calculateBTC(senderID) >= t.getAmount());
	}
	
	//calculate number of BTC I own in the longest block chain
	public double calculateBTC(){
		float btc = calculateBTC(this.uID);
		this.currOwned = btc;
		return btc;
	}
	
	private float calculateBTC(String ownerId) {
		float btc = 0;
		
		//Note: get parent block's transaction list for a given block from DB
		Block blk_iter = this.probParentBlock;
		
		while(blk_iter!=null) {			
			if(blk_iter.txnList != null && blk_iter.txnList.size() > 0) {
				
				for(Transaction tx: blk_iter.txnList) {
					if(ownerId.equals(tx.getSenderID())) {
						// deducting transaction amount if current node is sender
						btc -= tx.getAmount();
					}else if(ownerId.equals(tx.getReceiverID())){
						//incrementing transaction amount if current node is receiver
						btc += tx.getAmount();
					}
				}
			}

			blk_iter = blk_iter.getParentBlock();
		}
		
		return btc;
	}

	//Add Node to connected Nodes
	void connect2Node(Node newNode){
		connectedNode.add(newNode);
		numConnection++;
	}

	//userID return
	public String getUID(){
		return uID;
	}

	//type return
	public boolean getType(){
		return type;
	}

	//creationTime return
	public Timestamp getCreationTime(){
		return creationTime;
	}

	//userID return
	public float getCurrOwned(){
		return currOwned;
	}

	//to update the currently owned value
	public void updateCurrOwned(float newAmount){
		this.currOwned = newAmount;
	}

	//overwritting toString method for Node
	public String toString(){
		return "ID: "+this.uID+" type: "+ (this.type?"fast":"lazy") + " Creation time: "+this.creationTime  + " Balance: "+this.currOwned;
	}

	public Node connectedNodeAt(int index){
		if(index >= numConnection){
			return null;
		}
		else{
			return connectedNode.get(index);
		}		
	}

	//Function to check given a blockID or transactionID whether that is already being forwarded or not
	public boolean checkForwarded(String newID){
		return (forwardedMessage.containsKey(newID));		
	}

	public void addForwarded(String newID){
		this.forwardedMessage.put(newID, true);
	}
	
	
}