#include <iostream>
#include <cstring>
#include "string215.h"
using namespace std;

int test_string215();
void pause_215(bool have_newline);

int string215::str_len(const char *str) const
{
	int len = 0;
	const char *search;
	for(search = str; *search != '\0'; search++) {
		len++;
	}
	return len;
}

// Make and return a dynamically-allocated copy of the input C string.
char *string215::copy_string(const char *input)
{
	char *output = new char[str_len(input)+1];

	for(const char *scan = input; *scan != '\0'; scan++) {
		*output = *scan;
		output++;
	}
	*output = '\0';
	if(str_len(input) > 0) {
		output -= str_len(input);
	}
	return output;
}

// Return true if the two C strings contain the same sequence of characters.
bool string215::equal_string(const char *first, const char *second) const
{
	const char *scan1;
	const char *scan2; 

	if(str_len(first) == str_len(second)) {
		scan1 = first;
		scan2 = second;
		while(*scan1 != '\0') { 
			if(*scan1 != *scan2) {
				return false;
			}
			scan1++;
			scan2++;
		}
		return true;
	}
	return false;
}

// Destructor for the string215 class
string215::~string215()
{
	delete[] data;
}

// Constructor for thwe string215 class
string215::string215()
{
	char *arr = new char[0];
	arr[0] = '\0';
	data = arr;
}

// A copy constructor that allocates memory and performs a deep copy of the input object
string215::string215(const string215 &other)
{
	data = copy_string(other.data);
}

// Check whether two strings contain the same characters.
bool string215::equals(const string215 &other) const
{
	if(equal_string(data, other.data) == true) {
		return true;
	}
	return false;
}

// Return the length of a string215, not counting the null terminator.
int string215::length() const
{	
	return str_len(data);
}

// Return the character at a given index.  Returns '\0' if the
// index is out of bounds.
char string215::getchar(int index) const
{
	const char *stepper = data;
	if(index <= str_len(data) && index >= 0) {
		for(int x = 0; x < index; x++) {
			stepper++;
		}
		return *stepper;
	}
	return '\0';
}

// Set the character at a given index and return false.
bool string215::setchar(int index, char newchar)
{
	if(index <= str_len(data) && index >= 0) {
		for(int x = 0; x < index; x++) {
			data++;
		}
		*data = newchar;
		return true;
	}
	return false;
}

// Add a suffix to the end of this string.  Allocates and frees memory.
void string215::append(const string215 &suffix)
{
	char *output = new char[str_len(data)+suffix.length()+1];
	for(int x = 0; x < str_len(data); x++) {
		*output = *data;
		output++;
		data++;
	}

	for(int x = 0; x < suffix.length(); x++) {
		*output = suffix.getchar(x);
		output++;
	}
	*output = '\0';
	output -= (str_len(data)+suffix.length()+1);
	delete[] data;
	data = output;
}

// Return a pointer to the raw character data (not a copy).
const char *string215::c_str() const
{
	const char *pRaw = data;
	return pRaw;
}

// Create a string215 that is a (deep) copy of a C string.
string215::string215(const char *in_str)
{
	data = copy_string(in_str);
}

/* string215::replace() - Replace the contents of a string215 with the
*                        contents of a C string.
*
* Description:
*   Replace the contents of this string with a copy of the C string
*   argument.  Allocates memory for the new string array, performs a
*   deep copy of the input, and frees the old array.
*
* Inputs:
*   const char *in_str - The C string to copy into this object.
*   
* Outputs:
*   No return value.  The current string's contents are modified to be
*   character-by-character identical with the C string.
*/
void string215::replace(const char *in_str)
{
	delete[] data;
	data = new char[str_len(in_str)+1];
}


/* test_string215() - Test the string215 class.
*
* Description:
*   Run a number of tests of the various methods of the string215 class.
*
* Inputs:
*   No inputs.
*
* Outputs:
*   Prints a message about each failed test to cerr.  Returns the number of
*   failed tests.
*/
int test_string215()
{
	// Current test number.  Be sure to increment this before each test!
	int curr_test = 0;
	// Number of failed tests.
	int failed = 0;

	// TODO: Add at least two additional tests for the append method;
	// and four tests each for the setchar, equals, and replace methods.
	// Test both normal and boundary conditions.  If the test failed,
	// print a message to cerr and increment the 'failed' counter.
	//
	// Do not change or remove any of the existing tests!
	//
	// Note: This function is the only part of the program permitted to
	// use the functions strcmp, strlen, and so on.


	// Testing contents:
	// Tests 1-8 cover the constructors and c_str().
	// Tests 9-10 cover length().
	// Tests 11-12 cover getchar().
	// Tests 13-14 cover append().

	// Test 1: the default constructor and c_str().  An empty string
	// should still be terminated with a '\0' (at position 0), and in
	// particular should not be represented by a null pointer.
	curr_test++;
	string215 empty;
	const char *cs = empty.c_str();
	if (cs == NULL || cs[0] != '\0') {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 2: does the C string constructor faithfully copy its input?
	curr_test++;
	char letters[] = "some characters here";
	string215 full(letters);

	if (strcmp(letters, full.c_str()) != 0) {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 3: and did it do a deep copy?  The pointers should
	// differ.
	curr_test++;
	if (letters == full.c_str()) {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 4: make sure c_str() isn't making a copy.  If we call
	// it twice in a row, it should return the same address.
	curr_test++;
	if (full.c_str() != full.c_str()) {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 5: make sure we can copy an empty string.
	curr_test++;
	string215 empty_fromc("");
	cs = empty_fromc.c_str();
	if (cs[0] != '\0') {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 6: test that the copy constructor copies.
	curr_test++;
	string215 full_copy(full);
	if (strcmp(full_copy.c_str(), full.c_str()) != 0) {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 7: and that it does a deep copy.
	curr_test++;
	if (full_copy.c_str() == full.c_str()) {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 8: test the copy constructor on an empty string.
	curr_test++;
	string215 empty_copy(empty);
	cs = empty_copy.c_str();
	if (cs[0] != '\0' || cs == empty.c_str()) {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 9: test the length method.
	curr_test++;
	if (full.length() != strlen(full.c_str())) {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 10: also on an empty string.
	curr_test++;
	if (empty.length() != 0) {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 11: test getchar for the first and last characters.
	curr_test++;
	string215 str("testing");
	if (str.getchar(0) != 't' || str.getchar(str.length() - 1) != 'g') {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 12: also on out-of-bounds indices.
	curr_test++;
	if (str.getchar(-1) != '\0' || str.getchar(str.length()) != '\0'
		|| str.getchar(9999) != '\0')
	{
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 13: test that append works in a simple case.
	curr_test++;
	string215 suffix("123");
	str.append(suffix);
	if (strcmp(str.c_str(), "testing123") != 0) {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// Test 14: and that it didn't modify its argument.
	curr_test++;
	if (strcmp(suffix.c_str(), "123") != 0) {
		cerr << "Test " << curr_test << " failed." << endl;
		failed++;
	}

	// TODO: YOUR TESTS GO HERE

	// Finally, return the number of failed tests
	return failed;
}

/* pause_215() - Wait for the user to press ENTER.
*
* Description: 
*   Optionally read and discard the remainder of the user's last
*   line of input.  Then, prompt the user to press ENTER, then
*   read and discard another line of input.
*
* Inputs:
*   bool have_newline:
*     True if the user has already entered a newline that the
*     program has not yet read.  If true, this function first
*     discards remaining input up to and including that newline.
*
*   Reads two lines from standard input if have_newline is true,
*   one line if it is false.  Lines are assumed to be less than
*   two hundred characters long.
*
* Outputs:
*   No return value.
*
*   Prints a prompt to standard output.
*
* Notes:
*   This function is intended to be used at the end of a program,
*   just before returning from main().  Reading another line of
*   input prevents the console window from closing immediately.
*
*   In general, have_newline should be true if the last user input
*   from cin used the extraction operator (>>), and false if there
*   has been no user input or if the last input used getline().
*/
void pause_215(bool have_newline)
{
	if (have_newline) {
		// Ignore the newline after the user's previous input.
		cin.ignore(200, '\n');
	}

	// Prompt for the user to press ENTER, then wait for a newline.
	cout << endl << "Press ENTER to continue." << endl;
	cin.ignore(200, '\n');
}

int main()
{
	int failed = test_string215();

	if (failed == 0)
		cout << "All tests passed successfully." << endl;
	else
		cout << "Sorry, " << failed << " test(s) failed." << endl;

	pause_215(false);
	// Remember that returning zero from main indicates success, while
	// return anything else means that some kind of error occurred.
	return failed;
}