// Lab7-Actor-Army-File.cpp
#include <iostream>
#include <fstream>
#include <iomanip>
using namespace std;

#include "ColourConsole.h"
using namespace ColourConsole;

#include <conio.h>

// FUNCTION PROTOTYPES (function declarations; function definitions are at the bottom of the source code)
// Helper functions to handle safe keyboard input
void Get(int& rnNumToInput, char* pszPrompt, int nLow, int nHigh);
void Get(char* pszInput, char* pszPrompt, int nMaxNumCharacters);
int GetMenuSelection();
void Wait();

//**********************************************************************
// class Actor {
//**********************************************************************
class Actor {
private:
	static const int nMAX_STR_LEN = 31;
	char szName[nMAX_STR_LEN+1];
	int nStrength;
	int nSpeed;
	int nHealthPoints;

public:
	Actor() : nStrength(0), nSpeed(0), nHealthPoints(0) { szName[0] = '\0'; }
	bool Read(ifstream& rifsInput)
		{
		int nStrLen;
		rifsInput>>nStrLen;
		if (nStrLen > nMAX_STR_LEN) // ensure text being entered will fit within the allocated array of char
			return false;
		if (nStrLen > 0)						// if the Actor on disk has no name suppress input of 
			rifsInput.get(szName, nStrLen+1);
		rifsInput>>nStrength>>nSpeed>>nHealthPoints;
		return true;
		}
	void Write(ofstream& rofsOutput)
		{
		rofsOutput<<strlen(szName)<<szName<<' '<<nStrength<<' '<<nSpeed<<' '<<nHealthPoints;
		}
	void Set()
		{
		Get(szName, "Name: ", nMAX_STR_LEN);
		Get(nStrength, "Strength: ", 10, 200);
		Get(nSpeed, "Speed: ", 5, 50);
		Get(nHealthPoints, "Health Points: ", 10, 100);
		}
	void Display()
		{
		cout<<setw(22)<<szName<<setw(9)<<nStrength<<setw(9)<<nSpeed<<setw(9)<<nHealthPoints;
		}

	// STATIC FUNCTIONS
	// A static function is "class-oriented" rather than "object-oriented". It is called without using an Actor object.
	// It is called using the class scope resolution operator.
	static void DisplayHeadings()
		{
		cout<<setw(22)<<"Actor Name"<<setw(9)<<"Strength"<<setw(9)<<"Speed"<<setw(9)<<"Health"<<endl;
		}
}; // end class Actor

//**********************************************************************
// class Army {
//**********************************************************************
class Army {
	enum DisplayMode { ShowIndexNumbers, NoIndexNumbers };
private:
	static const int nMAX_ACTORS = 20;
	static const int nMAX_FILENAME_LEN = 127;

	char szFileName[nMAX_FILENAME_LEN+1];
	Actor aaActors[nMAX_ACTORS];
	int nNumActors;

public:
	Army() : nNumActors(0) { szFileName[0] = '\0'; }
	~Army() { Write(); } // file will be saved automatically when the Army object is destroyed
	int Read();
	int Write();
	void Display(DisplayMode dmIndexNumberVisibility = NoIndexNumbers);
	void Edit();
}; // end class Army

//**********************************************************************
// int Army::Read()
//**********************************************************************
int Army::Read()
{
cout << clear << fg_yellow << "Reading File From Disk\n\n" << fg_white;
int nOriginalNumActors = nNumActors;
cout << "Filename of Army: "; 
cin >> szFileName;
ifstream ifsIn(szFileName);
if (ifsIn.fail()) {
	cout << "Error: File Read: Unable to open " << szFileName << endl;
	return 0;
	}

while ( ! ifsIn.eof()) {
	if ( ! aaActors[nNumActors++].Read(ifsIn)) // terminate reading if any failure in file input
		break;
	}

ifsIn.close();
return nNumActors - nOriginalNumActors; // returns the number of Actor objects added.
}

//**********************************************************************
// int Army::Write()
//**********************************************************************
int Army::Write()
{
if (nNumActors == 0)
	return 0; // nothing to do since there are no Actor objects

ofstream ofsOut(szFileName); // file opened in an overwrite mode
if (ofsOut.fail()) {
	cout << "Error: File Write: Unable to open " << szFileName << endl;
	return 0;
	}

for (int i=0; i<nNumActors; i++) {
	aaActors[i].Write(ofsOut);
	if (i<nNumActors-1) // generate a newline on all but the last Actor object
		ofsOut << endl;
	}

ofsOut.close();
return nNumActors;
}

//**********************************************************************
// void Army::Display()
//**********************************************************************
void Army::Display(DisplayMode dmIndexNumberVisibility)
{
cout << clear << fg_yellow << "Actors in Army " << szFileName << endl << endl;
Actor::DisplayHeadings(); // call to a static function in class Actor
cout << fg_white;
for (int i=0; i<nNumActors; i++) {
	if (dmIndexNumberVisibility == ShowIndexNumbers)
		cout << fg_yellow << i << ": " << fg_white;
	aaActors[i].Display();
	cout << endl;
	}
}

//**********************************************************************
// void Army::Edit()
//**********************************************************************
void Army::Edit()
{
Display(ShowIndexNumbers);
int nIndex;
Get(nIndex, "\nEnter Index to Edit: ", 0, nNumActors-1);
aaActors[nIndex].Set();
}

//**********************************************************************
// void main()
//**********************************************************************
void main()
{
Army aForcesOfLight;
Army aForcesOfDarkness;

int nChoice;
do {
	nChoice = GetMenuSelection();
	switch (nChoice) {
		case 1: cout << "Number of Actors Input: " << aForcesOfLight.Read();	break;
		case 2: aForcesOfLight.Display();			break;
		case 3: aForcesOfLight.Edit();				break;
		case 4: aForcesOfLight.Write();				break;

		case 5: aForcesOfDarkness.Read();			break;
		case 6: aForcesOfDarkness.Display();	break;
		case 7: aForcesOfDarkness.Edit();			break;
		case 8: aForcesOfDarkness.Write();		break;
		} // end switch
	Wait();
	} while (nChoice != 9);
}

//**********************************************************************
// int GetMenuSelection()
//**********************************************************************
int GetMenuSelection()
{
cout << clear << fg_yellow << "Lab 1: BATTLEFIELD SIMULATOR\n\n" << fg_white;

cout << "1. Read Forces of Light\n";
cout << "2. Display Forces of Light\n";
cout << "3. Edit Forces of Light\n";
cout << "4. Write Forces of Light\n\n";

cout << "5. Read Forces of Darkness\n";
cout << "6. Display Forces of Darkness\n";
cout << "7. Edit Forces of Darkness\n";
cout << "8. Write Forces of Darkness\n\n";

cout << "9. Exit\n\n";

int nChoice;
Get(nChoice, "Enter choice: ", 1, 9);
return nChoice;
}

//**********************************************************************
// void Get(int& rnNumToInput, char* pszPrompt, int nLow, int nHigh)
//**********************************************************************
void Get(int& rnNumToInput, char* pszPrompt, int nLow, int nHigh)
{
cout << pszPrompt;
cin >> rnNumToInput;

while ( ! cin.good() || rnNumToInput<nLow	|| rnNumToInput>nHigh) {
	cin.clear();
	cin.ignore(128,'\n');
	cout << "Invalid entry.\nEnter number between " << nLow << " and " << nHigh << endl;
	cout << pszPrompt;
	cin >> rnNumToInput;
	}
}

//**********************************************************************
// void Get(char* pszInput, int nMaxNumCharacters)
//**********************************************************************
void Get(char* pszInput, char* pszPrompt, int nMaxNumCharacters)
{
cout << pszPrompt;
int i = 0;
char c;
while ((c = _getch()) != '\r') {
	if (c == '\b'  &&  i > 0) { // backspace
		--i;	// decrement index into char array, next input overwrites old
		putchar('\b');	// output backspace -- moves cursor backwards
		putchar(' ');		// overwrite old screen character to erase visual 
		putchar('\b');	// output backspace -- moves cursor backwards
		}
	else if (isprint(c)  &&  i < nMaxNumCharacters) {
		putchar(c);		// echo character to screen (not done by getch())
		pszInput[i] = c;	// capture keyboard character to char array 
		++i;						// next index position -- get ready for next char
		}
	}
pszInput[i] = '\0';	// place "end-of-string" flag after last input character
cout << endl;
}

//**********************************************************************
// void Wait()
//**********************************************************************
void Wait()
{
cout << "\nPress a key to continue . . .";
_getch();
}