#include "BigNat.h"
#include <stack>

using namespace std;

// Default constructor. 
// Pre: n >= 0
// Post: n = 0 -> D = _ /\ n != 0 -> D = digits of n, least significant
//                                                    first.

BigNat::BigNat(int n) {

	head = 0;
	err = Ok;
	Node *tmp;
	bool done = false;
	
	if (n < 0) {err = PreFail;}
	while (!done && err == Ok) {

		if(head == 0){tmp = head;}

		tmp->next = new Node;
		tmp = tmp->next;		
		
		if(tmp != 0){
			head -> next = tmp;
			tmp -> digit = n % 10;
			n = n - (n%10);
			n = n/10;
			if(n == 0) {done = true;}
		}
		else{err = NewFail;}
	}
}

// Copy constructor
BigNat::BigNat(const BigNat & r) {
	Node **tmp;
	Node *tmp2 = r.head;
	bool done = false;
	err = Ok;
	head = 0;

	while(!done && err == Ok) {
		if (head == 0 ){*tmp = head;}
		
		*tmp -> next = new Node;
		
		if(tmp != 0){
		    (*tmp)->digit = tmp2->digit;
		    tmp2 = (*tmp2)->next;
			tmp = &(*tmp)->next;
		}
		else { err = NewFail; }
	}
}


BigNat::~BigNat() {

	Node *tmp;
    while (head != 0) {
		Node *tmp = head->next;
		delete head;
		head = tmp;
    }
}
   
string BigNat::toString() const {

	string tempString;
	int integer;
	Node *tmp;
	stack<char>  tempStack;

	tmp = head;
	while (tmp != 0){
		integer = tmp->digit;

		switch(integer){
		case '0':
				tempStack.push(0);
				break;
		case '1':
				tempStack.push(1);
				break;
		case '2':
				tempStack.push(2);
				break;
		case '3':
				tempStack.push(3);
				break;
		case '4':
				tempStack.push(4);
				break;
		case '5':
				tempStack.push(5);
				break;
		case '6':
				tempStack.push(6);
				break;
		case '7':
				tempStack.push(7);
				break;
		case '8':
				tempStack.push(8);
				break;
		case '9':
				tempStack.push(9);
				break;
		default: 
				break;
		}

		while (!tempStack.empty()){
			tempString += tempStack.top();
			tempStack.pop();
		}

		return tempString;
	}



// Mutators
BigNat & BigNat::
operator =(const BigNat& r) {



}

// Post: D' = D + r /\ Result = D'
BigNat & BigNat::
operator += (const BigNat& r) {

}

// Pre: r > 0
// Post: D' = D + r /\ Result = D'
BigNat & BigNat::
operator += (int r) {

}
    
// Pre: 0 < r < 10
// Post: D' = D * r /\ Result = D'

BigNat & BigNat::
operator *= (int r) {

}