//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
PIMS: Personal Invstment Management System
Class : Security
Descrption: This class correspond to a Security. Any
access to Security (access/modification/edit 
transaction etc.) is done through the instance of this class.
The attributes are:
1> A list of all transactions.
2> Net-worth of the security
3> ComputeNetWorth(): Computes the net worth for this security
4> ComputeROI(): Computes the ROI of this security
5> Add/Delete/Edit    Transaction
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

import java.util.*;
import java.text.*;

public class security{

	private dataRepository DR;
	private CurrentValueSystem CVS;
	private String PortfolioName;//Name of the parent portfolio
	private SecurityDS SecurityData;//Information about this security.
	private Transaction TransactionList[];//A list of all transactions
	private int NumTransactions;//Number of transactions
	private double NetWorth;//The net worth of the security
	
	private final static double EPSILON = 0.1;
	private final static double INITIAL_RATE = 0.0;
	private final static double STEP_RATE = 0.5;
	
	public security(dataRepository DR, CurrentValueSystem CVS, String PortfolioName, SecurityDS SecurityData)throws Exception{
	
		this.DR = DR;
		this.CVS = CVS;
		this.PortfolioName = PortfolioName;;
		this.SecurityData = SecurityData;
		
		//Initialize the transactions list  by reading from the 
		//previously initialized file named by the security in the 
		//HOME/.pims/Investment/<portfolio> directory				
		TransactionList = DR.ReadTransactionList(PortfolioName, SecurityData);
		
		//Count the number of securities
		while(TransactionList[NumTransactions] != null)NumTransactions++;		
	}
	
	//Returns the transaction list
	public Transaction[] ReturnTransactionList()throws Exception{
		
		return(TransactionList);
	}

	//Checks if transaction 1 happened before transaction 2
	private boolean dateLessThan(Transaction Trans1, Transaction Trans2){
	
		if(Trans1.Year < Trans2.Year)return(true);
		if(Trans1.Year > Trans2.Year)return(false);
		
		//transactions happened in the same year
		if(Trans1.Month < Trans2.Month)return(true);
		if(Trans1.Month > Trans2.Month)return(false);
		
		//transactions happened in the same year and same month
		if(Trans1.Day < Trans2.Day)return(true);
		if(Trans1.Day > Trans2.Day)return(false);
		
		//transactions happened on the same date
		return(false);
	}
	
	//Sorts the transaction list based on the transaction date	
	private Transaction[] sortTransactions(){
		
		int j,k;
		Transaction tempTransaction;

		Transaction trans[] = new Transaction[NumTransactions];
		//Copy the transaction list
		for(k=0;k<NumTransactions;++k)trans[k] = TransactionList[k];
		
		for (k=1 ; k<NumTransactions ; ++k){
			tempTransaction = trans[k];
			
			for (j=k ; (j>0) && (dateLessThan(tempTransaction, trans[j-1])) ; --j)
				trans[j] = trans[j-1];
				
			trans[j] = tempTransaction; // put element in his new index.
		}
		
		return(trans);
	}
	
	//Computes the month difference
	private int calculateMonthDifference(int year2, int month2, int day2, int year1, int month1, int day1){
	
		return(((year2 - year1)*365 + (month2 - month1)*30 + day2 - day1)/30);
	}
	
	//returns sign appropriately
	private double Sign(boolean TransType){
		
		if(TransType)return(-1.0);
		else return(1.0);
	}
	
	//Computation of net worth for bank type
	private double NetWorthCalculationForBank()throws Exception{
		
		double value = 0.0;
		double rate = SecurityData.RateOfInterest;
		int i, prevDay, prevMonth, prevYear, months;
		int Month, Year, Day;
		String line;
		
		if(NumTransactions == 0)return(0.0);
		
		//Sort the transactions based on the date
		Transaction trans[] = sortTransactions();
		
		value = Sign(trans[0].TransType)*trans[0].AmountTransacted;
		prevYear = trans[0].Year;
		prevMonth = trans[0].Month;
		prevDay = trans[0].Day;
		for(i=1;i<NumTransactions;++i){
		
			months = calculateMonthDifference(trans[i].Year, trans[i].Month, trans[i].Day, prevYear, prevMonth, prevDay);
			prevYear = trans[i].Year;
			prevMonth = trans[i].Month;
			prevDay = trans[i].Day;
			value = value*Math.pow(1+rate/100, (double)months);
			value += Sign(trans[i].TransType)*trans[i].AmountTransacted;
		}
		//get the current date and compute the final net worth by adding the interest upto the present date
		Date date = new Date();
		String dat = (DateFormat.getInstance()).format(date);
		StringTokenizer ST = new StringTokenizer(dat, "/");
		Month = Integer.parseInt(ST.nextToken());
		Day = Integer.parseInt(ST.nextToken());
		line = ST.nextToken();
		ST = new StringTokenizer(line);
		Year = 2000 + Integer.parseInt(ST.nextToken());
		months = calculateMonthDifference(Year, Month, Day, prevYear, prevMonth, prevDay);
		value = value*Math.pow(1+rate/100, months);
		
		return(value);
		
	}
	
	//returns the number of shares in a share type security.
	public int numShares(int index)throws Exception{
		
		int i, Balance = 0;
		
		//Find out the balance number of shares
		for(i=0;i<NumTransactions;++i){
			if(i == index)continue;
			if(TransactionList[i].TransType)Balance -= TransactionList[i].NumShares;
			else Balance += TransactionList[i].NumShares;
		}
		return(Balance);	
	}
	
	//Computation of the net worth for share type 
	private double NetWorthCalculationForShare()throws Exception{
	
		int i;
		int Balance = 0;
		double CurrentPrice;
		
		//Find out the balance number of shares
		for(i=0;i<NumTransactions;++i){
			if(TransactionList[i].TransType)Balance -= TransactionList[i].NumShares;
			else Balance += TransactionList[i].NumShares;
		}
		
		//Find out the current price of the share
		CurrentPrice = CVS.priceOfShare(SecurityData.CompanyName);
		
		return(CurrentPrice*Balance);
	}
	
	//Compute the net worth of the security
	public double ComputeNetWorth()throws Exception{
		
		//Compute the net worth of this security
		if(SecurityData.Bank)
			NetWorth = NetWorthCalculationForBank();
		else 
			NetWorth = NetWorthCalculationForShare();
			
		return(NetWorth);
	}
	
	//Add a transaction to this security
	public boolean AddTransaction(Transaction Trans)throws Exception{
	
		//Do the file operations for adding transaction
		if(!DR.AddTransaction(PortfolioName, SecurityData, Trans))return(false);
		
		//Add the trasnaction in the transaction list
		TransactionList[NumTransactions++] = Trans;
		
		//Modify the net worth of the security
		if(Trans.TransType)//bank type
			if(Trans.TransType)NetWorth -= Trans.AmountTransacted;
			else NetWorth += Trans.AmountTransacted;
		else
			if(Trans.TransType)NetWorth -= Trans.NumShares*Trans.CostOfShare;
			else NetWorth += Trans.NumShares*Trans.CostOfShare;
			
		return(true);
	}
	
	//Delete a transaction from the security
	public boolean DeleteTransaction(int index)throws Exception{
		
		int i;
		
		//Do the file operations for deletion
		if(!DR.DeleteTransaction(PortfolioName, SecurityData, index))return(false);
		
		//Delete the transaction from the transaction list
		for(i = index;i<NumTransactions-1;++i)
			TransactionList[i] = TransactionList[i+1];
			
		NumTransactions--;
		
		//Recompute the net worth of this security
		if(SecurityData.Bank)
			NetWorth = NetWorthCalculationForBank();
		else 
			NetWorth = NetWorthCalculationForShare();
			
		return(true);
	}
	
	//Edit a transaction
	public boolean EditTransaction(int index, Transaction Trans)throws Exception{
	
		//Do the file operations related to the editing
		if(!DR.EditTransaction(PortfolioName, SecurityData, index, Trans))return(false);
		
		//Edit the transaction in the TransactionList
		TransactionList[index] = Trans;
		
		//Recompute the net worth of this security
		if(SecurityData.Bank)
			NetWorth = NetWorthCalculationForBank();
		else 
			NetWorth = NetWorthCalculationForShare();
			
		return(true);
	}
	
	//Compute the ROI of this security.
	public double ComputeROI()throws Exception{
	
		if(SecurityData.Bank)return(SecurityData.RateOfInterest);
		else return(ComputeROIForShare());
	}

	private double giveNetWorthValueForRate(double rate)throws Exception{
		
		double value = 0.0;
		int i, prevDay, prevMonth, prevYear, months;
		int Month, Year, Day;
		String line;
		
		if(NumTransactions == 0)return(0.0);
		
		//Sort the transactions based on the date
		Transaction trans[] = sortTransactions();
		
		value = Sign(trans[0].TransType)*trans[0].NumShares*trans[0].CostOfShare;
		prevYear = trans[0].Year;
		prevMonth = trans[0].Month;
		prevDay = trans[0].Day;
		for(i=1;i<NumTransactions;++i){
		
			months = calculateMonthDifference(trans[i].Year, trans[i].Month, trans[i].Day, prevYear, prevMonth, prevDay);
			prevYear = trans[i].Year;
			prevMonth = trans[i].Month;
			prevDay = trans[i].Day;
			value = value*Math.pow(1+rate/100, (double)months);
			value += Sign(trans[i].TransType)*trans[i].NumShares*trans[i].CostOfShare;
		}
		//get the current date
		Date date = new Date();
		String dat = (DateFormat.getInstance()).format(date);
		StringTokenizer ST = new StringTokenizer(dat, "/");
		Month = Integer.parseInt(ST.nextToken());
		Day = Integer.parseInt(ST.nextToken());
		line = ST.nextToken();
		ST = new StringTokenizer(line);
		Year = 2000 + Integer.parseInt(ST.nextToken());
		months = calculateMonthDifference(Year, Month, Day, prevYear, prevMonth, prevDay);
		value = value*Math.pow(1+rate/100, months);
		
		return(value);
		
	}
	//returns the Rate of interest of a share type	The algorithm is as follows:
	//First the net worth of this security is computed (from balance number of shares)
	//Then we try to find the rate which if applied on the all transactions would give
	//this net worth. The rate is found iteratively each time making a better guess and
	//finally converging to the final value.
	private double ComputeROIForShare()throws Exception{
	
		double net_worth = ComputeNetWorth();
		double net_worth_guessed;
		double rate = INITIAL_RATE;
		double step_rate = STEP_RATE;
		boolean prevGuess = false;//true for more false for less
		boolean thisGuess = false;
		
		if(NumTransactions == 0)return(0.0);
		
		net_worth_guessed = giveNetWorthValueForRate(rate);
		if(net_worth_guessed > net_worth)prevGuess = true;
		else prevGuess = false;
		
		while(true){
			net_worth_guessed = giveNetWorthValueForRate(rate);
			
			if(Math.abs(net_worth_guessed - net_worth) < EPSILON)break;
			
			if(net_worth_guessed > net_worth)thisGuess = true;
			else thisGuess = false;
			
			if(!prevGuess && thisGuess){
				rate -= step_rate/2;
				step_rate = step_rate/2;
			}
			if(prevGuess && !thisGuess){
				rate += step_rate/2;
				step_rate = step_rate/2;
			}
			if(!prevGuess && !thisGuess){
				rate += step_rate;
			}
			if(prevGuess && thisGuess){
				rate -= step_rate;
			}
			prevGuess = thisGuess;
		}
		return(rate);
	}
}