//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
PIMS: Personal Invstment Management System
Class : Investment
Descrption: This class correspond to the entire Investment. Any
access to investment (access/modification/edit portfolios/securities/
transaction etc.) is done through the instance of this class.
the instance of this class
The attributes are:
1> A list of all portfolio names.
2> Net-worth
3> ComputeNetWorth(): Returns the value of Net-Worth. Each time the
       Investment is accessed, the value of the Net-Worth is modified.
4> ComputeROI: Computes the ROI of a particular security
5> Add/Delete/Rename/Edit    Portfolio/Security/Transaction
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public class Investment{

	private dataRepository DR;
	private CurrentValueSystem CVS;
	private String PortfolioList[];//A list of all portfolio names.
	private int NumPortfolios;//Number of portfolios
	private double NetWorth;//The networth of the investment.
	
	public Investment(dataRepository DR, CurrentValueSystem CVS)throws Exception{
	
		this.DR = DR;
		this.CVS = CVS;
		
		//Initialize the portfolio list  by reading from the 
		//previously initialized file "portfolios" in the 
		//HOME/.pims/Investment directory
		PortfolioList = DR.ReadPortfolioList();
		
		//Count the number of portfolios.
		while(PortfolioList[NumPortfolios] != null)NumPortfolios++;				
	}
	
	public boolean ReturnTypeOfSecurity(String PortfolioName, String SecurityName)throws Exception{
		
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		return(port.ReturnTypeOfSecurity(SecurityName));
	}
	
	//Returns the list of portfolios
	public String[] ReturnPortfolioList()throws Exception{
		return(PortfolioList);
	}
	
	//Returns the number of shares in a share type security.
	public int numShares(String PortfolioName, String SecurityName, int index)throws Exception{
		
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		return(port.numShares(SecurityName, index));
	}
	
	//Returns the list of securities
	public SecurityDS[] ReturnSecurityList(String PortfolioName)throws Exception{
		
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		return(port.ReturnSecurityList());
	}
	
	//Returns the list of transaction
	public Transaction[] ReturnTransactionList(String PortfolioName, String SecurityName)throws Exception{
	
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		return(port.ReturnTransactionList(SecurityName));
	}
	
	//Returns the net worth of the investment
	public double ComputeNetWorth()throws Exception{
	
		//Compute the NetWorth of the Investment
		NetWorth = 0.0;
		for(int i=0;i<NumPortfolios;++i){
			NetWorth += (new Portfolio(DR, CVS, PortfolioList[i])).ComputeNetWorth();
		}
	
		return(NetWorth);
	}
	
	//Returns the net worth of the specified portfolio.
	public double ComputeNetWorth(String PortfolioName)throws Exception{
	
		Portfolio port  = new Portfolio(DR, CVS, PortfolioName);
		
		return(port.ComputeNetWorth());
	}
	
	//Returns the net-worth of a specified security in a specified portfolio
	public double ComputeNetWorth(String PortfolioName, String SecurityName)throws Exception{
	
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		
		return(port.ComputeNetWorth(SecurityName));
	}
	
	//Checks if a portfolio of the same name already exists
	public boolean CheckPortfolioName(String PortfolioName)throws Exception{
	
		for(int i=0;i<NumPortfolios;++i){
			if(PortfolioName.equals(PortfolioList[i]))return(true);
		}
		
		return(false);
	}
	
	//Checks if a security of the same name already exists in the portfolio
	public boolean CheckSecurityName(String PortfolioName, String SecurityName)throws Exception{
	
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		
		return(port.CheckSecurityName(SecurityName));
	}
	
	//Adds a portfolio into the investment
	public boolean AddPortfolio(String PortfolioName)throws Exception{
	
		if(!DR.AddPortfolio(PortfolioName))return(false);//Does appropriate file operations to add a portfolio
		
		PortfolioList[NumPortfolios++] = PortfolioName;
		return(true);
	}
	
	//Deletes a portfolio from the investment
	public boolean DeletePortfolio(String PortfolioName)throws Exception{
	
		int i;
		
		//Compute the new net worth of the Investment by subtracting 
		//the net worth of the deleted portfolio.
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		NetWorth -= port.ComputeNetWorth();
		//
		
		if(!DR.DeletePortfolio(PortfolioName))return(false);//does file operations related to the deletion
		
		//Search this portfolio in the PortfolioList
		for(i=0;i<NumPortfolios;++i)
			if(PortfolioName.equals(PortfolioList[i]))break;
			
		for(;i<NumPortfolios;++i)
			PortfolioList[i] = PortfolioList[i+1];
			
		NumPortfolios--;
		PortfolioList[NumPortfolios] = null;
		
		return(true);
	}
	
	//Renames a particular portfolio.
	public boolean RenamePortfolio(String OldPortfolioName, String NewPortfolioName)throws Exception{
	
		//Do the file operations
		if(!DR.RenamePortfolio(OldPortfolioName, NewPortfolioName))return(false);
		
		//Find the portfolio in the portfolio list
		for(int i=0;i<NumPortfolios;++i)
			if(OldPortfolioName.equals(PortfolioList[i])){
				PortfolioList[i] = NewPortfolioName;
				break;
			}
			
		return(true);
	}
	
	//Add a security to a specified portfolio
	public boolean AddSecurity(String PortfolioName, SecurityDS SecurityData)throws Exception{
	
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		
		return(port.AddSecurity(SecurityData));
	}
	
	//Delete a security from the specified portfolio.
	public boolean DeleteSecurity(String PortfolioName, String SecurityName)throws Exception{
	
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		
		//call the function to delete the security
		if(!port.DeleteSecurity(SecurityName))return(false);
		
		//update the net worth
		NetWorth -= port.ComputeNetWorth();
		
		return(true);
	}
	
	//Rename a security in a given portfolio
	public boolean RenameSecurity(String PortfolioName, String OldSecurityName, String NewSecurityName)throws Exception{
	
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		
		return(port.RenameSecurity(OldSecurityName, NewSecurityName));
	}
	
	//Adds a transaction to a security ina given portfolio
	public boolean AddTransaction(String PortfolioName, String SecurityName, Transaction Trans)throws Exception{
	
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		
		//Update net worth
		NetWorth -= port.ComputeNetWorth();
		
		if(!port.AddTransaction(SecurityName, Trans))return(false);
		
		//Update the net worth
		NetWorth += port.ComputeNetWorth();
		
		return(true);
	}
	
	//Deletes a transaction of a security from a given portfolio
	public boolean DeleteTransaction(String PortfolioName, String SecurityName, int index)throws Exception{
	
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		
		NetWorth -= port.ComputeNetWorth();
		
		if(!port.DeleteTransaction(SecurityName, index))return(false);
		
		NetWorth += port.ComputeNetWorth();
		
		return(true);
	}
	
	//Deletes a transaction of a security from a given portfolio
	public boolean EditTransaction(String PortfolioName, String SecurityName, int index, Transaction Trans)throws Exception{
	
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		
		NetWorth -= port.ComputeNetWorth();
		
		if(!port.EditTransaction(SecurityName, index, Trans))return(false);
		
		NetWorth += port.ComputeNetWorth();
		
		return(true);
	}
	
	//Computes the ROI of a given security in a given portfolio
	public double ComputeROI(String PortfolioName, String SecurityName)throws Exception{
	
		Portfolio port = new Portfolio(DR, CVS, PortfolioName);
		
		return(port.ComputeROI(SecurityName));
	}
}