#include <iostream.h>
#include <iomanip.h>
#include <string.h>
#include <assert.h>
#include "team1.h"

/////////////////////////////////////////////////////////////////////////////
// Definition of Player's member functions
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// Constructors
/////////////////////////////////////////////////////////////////////////////

Player::Player()
{
  strcpy(last_name,"\0");
  strcpy(first_name,"\0");
  strcpy(position,"\0");
  batting=0.0;
  era=0.0;
  salary=0;
}

Player::Player(char* l_n, char* f_n)
{
  set_last_name(l_n);
  set_first_name(f_n);
  strcpy(position,"\0");
  batting=0.0;
  era=0.0;
  salary=0;
}

Player::Player(Player& p)
{
  set_last_name(p.last_name);
  set_first_name(p.first_name);
  set_position(p.position);
  set_b_a(p.batting);
  set_era(p.era);
  set_salary(p.salary);
}

/////////////////////////////////////////////////////////////////////////////
// set functions
/////////////////////////////////////////////////////////////////////////////

void Player::set_last_name(char* l_n)
{
  strcpy(last_name, l_n);
}

void Player::set_first_name(char* f_n)
{
  ...
}

void Player::set_position(char* p)
{
  ...
}

void Player::set_b_a(double b)
{
  batting=b;
}

void Player::set_era(double e)
{
  ...
}

void Player::set_salary(int s)
{
  ...
}

/////////////////////////////////////////////////////////////////////////////
// get functions
/////////////////////////////////////////////////////////////////////////////

char* Player::get_last_name()
{
  return last_name;
}

char* Player::get_first_name()
{
  ...
}

char* Player::get_position()
{
  ...
}

double Player::get_ba()
{
  ...
}

double Player::get_era()
{
  ...
}

int Player::get_salary()
{
  ...
}

//I don't think this function is needed!!!
Player Player::operator=(Player& p)
{
  Player p1(p);
	
  return p1;
}

/////////////////////////////////////////////////////////////////////////////
// friend functions--overloading of operators
/////////////////////////////////////////////////////////////////////////////

ostream& operator<<(ostream& out, const Player& p)
{
   char last_name[20];
   char first_name[20]; 
   char position[3];
   double batting;
   double era;
   int salary;
   
   strcpy(last_name, p.last_name);
   strcpy(first_name, p.first_name);
   strcpy(position, p.position);
   batting=p.batting;
   era=p.era;
   salary=p.salary;

   cout.setf(ios::fixed);	//this piece of code makes sure all doubles are
   cout.setf(ios::showpoint); 	//outputed with two decimal places.
   cout.precision(2);

   out<<setw(10)<<last_name;
   out<<setw(10)<<first_name;
   out<<setw(10)<<position;
   out<<setw(10)<<batting;
   out<<setw(10)<<era;
   out<<setw(10)<<salary<<endl;
   
   return out;
}

istream& operator>>(istream& in, Player& p)
{
  char last_name[20];
  char first_name[20];
  char position[3];
  double batting;
  double era;
  int salary;
  
  in>>last_name;
  in>>first_name;
  in>>position;
  in>>batting;
  in>>era;
  in>>salary;

  p.set_last_name(last_name);
  p.set_first_name(first_name);
  p.set_position(position);
  p.set_b_a(batting);
  p.set_era(era);
  p.set_salary(salary);
	
  return in;
}

bool operator==(const Player& p1, const Player& p2)
{
  return (!(strcmp(p1.last_name, p2.last_name)) && !(strcmp(p1.first_name, p2.first_name))) && !(strcmp(p1.position,p2.position)) && (p1.batting==p2.batting) && (p1.era==p2.era) && (p1.salary==p2.salary);
}

bool operator!=(const Player& p1, const Player& p2)
{
  return !(p1==p2);
}

/////////////////////////////////////////////////////////////////////////////
// end of definitions of Player's functions
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// Definition of Team's member functions
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// Consructors
/////////////////////////////////////////////////////////////////////////////

Team::Team()
{
	int k;
	max=10;
	players=new Player[max];
	used=0;
}

Team::Team(int s)
{
	max=s;
	players=new Player[max];
	used=0;
}

//Modified!!!
Team::Team(const Team& t)
{
	max=t.max;
	players=new Player[t.max];
	used=t.used;
	
	int k;
	
	for (k=0; k<max; k++)
		players[k]=t.players[k];
}

Team::~Team()
{
	delete [] players;
}

//this function should return the value of used, not max!!!
int Team::size()
{
	return used;
}

void Team::update_player(char* l_n, char* f_n)
{
	int k=locate_player(l_n,f_n);
	char absorber, choice;
	char last_name[20];
	char first_name[20];
	char position[3];
	double batting;
	double era;
	int salary;

	if (k==-1)
		add_player(l_n,f_n);
	
	else
    {
		do
	  	{
			strcpy(last_name, players[k].get_last_name());
			strcpy(first_name, players[k].get_first_name());
			cout<<"Please select information you want to update for player "<<first_name<<' '<<last_name<<endl;
			cout<<"(a) Update position."<<endl;
			cout<<"(b) Update batting average."<<endl;
			cout<<"(c) Update earned run average (era)."<<endl;
			cout<<"(d) Update salary."<<endl;
			cout<<"(e) Finish updating player."<<endl;

			cin.get(choice);
			
			switch (choice)
			{
				case 'a':
				cout<<"Enter new position for "<<first_name<<' '<<last_name<<endl;
				cin.get(absorber);
				cin.getline(position,4);
				players[k].set_position(position);
				break;
				
				case 'b':
				...
				players[k].set_b_a(batting);
				break;

				case 'c':
				...
				break;

				case 'd':
				...
				break;
				
				case 'e':
				cout<<"You have now finished updating player "<<first_name<<' '<<last_name<<endl;
				break;
				
				default:
				cout<<"Invalid option.  Try again"<<endl;
			}
		}while(choice !='e');
    }
}

//Modified!!!
void Team::add_player(char* l_n, char* f_n)
{
	players[used].set_last_name(l_n);
	players[used].set_first_name(f_n);
	
	used=used+1;
	
	cout<<"Player "<<players[used-1].get_first_name()<<' '<<players[used-1].get_last_name()<<" has been added to the team"<<endl;
}

//Modified!!!
void Team::erase_player(char* l_n, char* f_n)
{
	int k=locate_player(l_n, f_n);
	
	players[k].set_last_name(players[used-1].get_last_name());
	players[k].set_first_name(players[used-1].get_first_name());
	...
	
	Player p1;
	players[used-1].set_last_name(p1.get_last_name());
	players[used-1].set_first_name(p1.get_first_name());
	...	
	
	used=used-1;
}

//This function checks whether a player with given first and last names exist and
//returns its position in the array players
int Team::locate_player(char* l_n, char* f_n)
{
	int k=0;
	int p=-1;
	char first_name[20];
	char last_name[20];
	
	while(k<used)
	{
		strcpy(last_name, players[k].get_last_name());
		strcpy(first_name, players[k].get_first_name());
		
		if ((strcmp(last_name, l_n)==0) && (strcmp(first_name, f_n)==0))
		{
			p=k;
			k=used;
		}
		
		else
			k=k+1;
	}
		return p;
}

ostream& operator<<(ostream& out, Team& t)
{
	int j;
	int size=t.size();
	
	for(j=0; j<size; j++)
	{
		Player p(t.players[j]);
		out<<p<<endl;
	}
	
	return out;
}

Team operator+ (const Team& t1, const Team& t2)
{
	int j,k;
	
	Team new_team(t1.max+t2.max);

	for (j=0; j<t1.used; j++)
	  new_team.players[j]=t1.players[j];

	for (k=t1.used; k<t1.used+t2.used; k++)
	  new_team.players[k]=t2.players[k-t1.used];

	return new_team;
}

Team Team::operator=(const Team& t)
{
	Team t1(t);
	
	return t1;
}