#include <iostream>
#include <fstream>
#include <string>
#include <assert.h>
#include <iomanip>
#define infile "InData.txt"
#define outfile "OutData.txt"
#define errorfile "ErrorData.txt"
#define outfile2 "Sums.txt"

using namespace std;
ifstream ins; //input file
ofstream ons; //valid output file
ofstream ens; //error file
ofstream sums;
ifstream sumsin;

struct CreditCard
{
	string CardNumber;
	string CardBrand;
	int SumProductEven;
	int SumOdd;
	int CardLength;
	string Validity;
};

CreditCard CreditCards[9999];

bool ProcessingOption()
{
	char Affirm;
	bool AssertionUse;

	cout << "Hello, and welcome to Cameron Labut's credit card verifying program." << endl;
	cout << "Would you like to break operations at the first invalid credit card length, or continue with operations and note the invalid card(s)?" << endl;
	cout << "If you want to break on invalid cards, type y, if not, type n" << endl;

	cin >> Affirm;

	if (Affirm == 'y' || Affirm == 'Y')
	{
		AssertionUse = true;

	}
	else if (Affirm = 'n' || Affirm == 'N')
	{
		AssertionUse = false;
	}

		return(AssertionUse);
}

int GetCardNumbers()
{
	int TotalCards;
	TotalCards = 0;

	ins.open(infile);

	if (ins.fail())
	{
		cout << "File open error, verify file exists." << endl;
	}

	do
	{
		ins >> CreditCards[TotalCards].CardNumber;

		TotalCards = TotalCards + 1;

	} while (!ins.eof());

	return(TotalCards);

}

void CreditCardType(int TotalCards)
{
	int TotalCards2; //since the silly arrays wont allow variables, I have to keep setting it to zero as a workaround, instead of the more direct way of actually using the number of cards, I have to loop.
	TotalCards2 = 0;

	do
	{

		if (CreditCards[TotalCards2].CardNumber.at(0) == '4' )
		{
			CreditCards[TotalCards2].CardBrand = "Visa";

		}
		else if (CreditCards[TotalCards2].CardNumber.at(0) == '5')
		{
			CreditCards[TotalCards2].CardBrand = "MasterCard";
		}
		else if (CreditCards[TotalCards2].CardNumber.at(0) == 3 && CreditCards[TotalCards2].CardNumber.at(1) == '7')
		{
			CreditCards[TotalCards2].CardBrand = "American Express";

		}
		else if (CreditCards[TotalCards2].CardNumber.at(0) == '6')
		{
			CreditCards[TotalCards2].CardBrand = "Discover";

		}
		else
		{
			CreditCards[TotalCards2].CardBrand = "Void";
		}

		TotalCards2 = TotalCards2 + 1;


	} while (TotalCards2 < TotalCards);



}

void GetLengthAssertTrue(int TotalCards)
{
	int TotalCards4;
	TotalCards4 = 0;

	do
	{
		if (CreditCards[TotalCards4].CardNumber.length() < 13 || CreditCards[TotalCards4].CardNumber.length() > 16)
		{
			const int i = 0;
			assert(i == 1);
		}
		else if (CreditCards[TotalCards4].CardNumber.length() >= 13 && CreditCards[TotalCards4].CardNumber.length() <= 16)
		{
			CreditCards[TotalCards4].CardLength = CreditCards[TotalCards4].CardNumber.length();

		}

		TotalCards4 = TotalCards4 + 1;

	} while (TotalCards4 < TotalCards);

}


void GetLengthAssertFalse(int TotalCards)
{
	int TotalCards5;
	TotalCards5 = 0;
	int ErrorCount = 1;

	ens.open(errorfile);

	do
	{
		if (CreditCards[TotalCards5].CardNumber.length() < 13 || CreditCards[TotalCards5].CardNumber.length() > 16)
		{
			cout << "WARNING - A card number is invalid, writing relevant data to ErrorData.txt" << endl;

			if (ErrorCount == 1)
			{
				ens << "Invalid Card Numbers due to Length" << endl;
			}

			ens << CreditCards[TotalCards5].CardNumber << endl;

			CreditCards[TotalCards5].CardLength = CreditCards[TotalCards5].CardNumber.length();

			ErrorCount = ErrorCount + 1;

		}
		else if (CreditCards[TotalCards5].CardNumber.length() >= 13 && CreditCards[TotalCards5].CardNumber.length() <= 16)
		{
			CreditCards[TotalCards5].CardLength = CreditCards[TotalCards5].CardNumber.length();
		}

		TotalCards5 = TotalCards5 + 1;

	} while (TotalCards5 < TotalCards);

	ens.close();
}

#include <iostream>
#include <cctype>
#include <cassert>
#include <vector>
#include <algorithm>
#include <string>

int double_it( int digit )
{
    assert( digit >= 0 && digit <= 9 ) ; // 'if the user wants to use assertions'

    const int dbl[] = { 0, 2, 4, 6, 8, 1, 3, 5, 7, 9 } ;
    return dbl[digit] ;
}

 // from right to left, double every second number in the card
 // http://www.mochima.com/tutorials/vectors.html
 int sum_of_double_even_place_right_to_left( std::vector<int> digits ) // passed by value
 {
     // http://en.cppreference.com/w/cpp/algorithm/reverse
     std::reverse( digits.begin(), digits.end() ) ; // reverse the digits
     int sum = 0 ;

     // for every second digit, starting at position 1
     for( std::size_t i = 1 ; i < digits.size() ; i += 2 ) sum += double_it( digits[i] ) ;
     return sum ;
 }

 int sum_of_odd_places_right_to_left( std::vector<int> digits ) // passed by value
 {
     std::reverse( digits.begin(), digits.end() ) ; // reverse the digits
     int sum = 0 ;

     // for every second digit, starting at position 0
     for( std::size_t i = 1 ; i < digits.size() ; i += 2 ) sum += digits[i] ;
     return sum ;
 }

 bool final_sum_ends_in_zero( std::vector<int> digits )
 {
     const int final_sum = sum_of_double_even_place_right_to_left(digits) +
                           sum_of_odd_places_right_to_left(digits) ;
     return final_sum%10 == 0 ;
 }

 std::vector<int> string_to_vector( std::string digits )
 {
     std::vector<int> result ;

     for( char c : digits ) // http://www.stroustrup.com/C++11FAQ.html#for
     {
         // http://en.cppreference.com/w/cpp/string/byte/isdigit
         assert( std::isdigit(c) ) ; // 'if the user wants to use assertions'

         // http://en.cppreference.com/w/cpp/container/vector/push_back
         result.push_back( c - '0' ) ; // ( '6' - '0' ) == 6 etc.
     }

     return result ;
 }

int main()
{
    const std::string card = "4388576018402626" ;
    std::cout << std::boolalpha << "final_sum_ends_in_zero? "
              << final_sum_ends_in_zero( string_to_vector(card) ) << '\n' ;
}

#include <iostream>
#include <cassert>
#include <string>

bool is_digit( char c ) { return c >= '0' && c <= '9' ; }

int double_it( char digit )
{
    assert( is_digit(digit) ) ;

    const int dbl[] = { 0, 2, 4, 6, 8, 1, 3, 5, 7, 9 } ;
    const int ival = digit - '0' ; // integer value of digit
    return dbl[ival] ;
}

std::string reverse( std::string str )
{
     std::string rev ;
     for( std::size_t i = 0 ; i < str.size() ; ++i ) rev = str[i] + rev ;
     return rev ;
}

 // from right to left, double every second number in the card
 int sum_of_double_even_place_right_to_left( std::string digits )
 {
     const std::string rev = reverse(digits) ;
     int sum = 0 ;
     // for every second digit, starting at position 1
     for( std::size_t i = 1 ; i < rev.size() ; i += 2 ) sum += double_it( rev[i] ) ;
     return sum ;
 }

 int sum_of_odd_places_right_to_left( std::string digits )
 {
     const std::string rev = reverse(digits) ;
     int sum = 0 ;
     // for every second digit, starting at position 0
     for( std::size_t i = 1 ; i < rev.size() ; i += 2 )
     {
         const int ival = digits[i] - '0' ; // integer value of digit
         sum += ival ;
     }
     return sum ;
 }

 bool final_sum_ends_in_zero( std::string digits )
 {
     for( std::size_t i = 0 ; i < digits.size() ; ++i ) assert( is_digit( digits[i] ) ) ;

     const int final_sum = sum_of_double_even_place_right_to_left(digits) +
                           sum_of_odd_places_right_to_left(digits) ;
     return final_sum%10 == 0 ;
 }

int main()
{
    const std::string card = "4388576018402626" ;
    std::cout << std::boolalpha << "final_sum_ends_in_zero? "
              << final_sum_ends_in_zero(card) << '\n' ;
}

#include <fstream>
#include <assert.h>
#include <string>
#include <iostream>
#define infile "Numbers.txt"
#define errorfile "InvalidCards.txt"

using namespace std;
ifstream ins;
ofstream ens;

struct CreditCard
{
	string Validity;
	string CardNumber;
	string CardType;
	int TotalCards; // only stored in the first (0) member of the array, denotes total cards.
	int CardLength;
};

CreditCard CreditCards[9998];

bool AssertCheck()
{
	char Affirm;
	bool Assert;
	cout << "Hello, and welcome to xxx's credit card validating program. Would you like to break all operations when an invalid number is found, or write the offending card(s) to an error file and continue?" << endl;
	cout << "If you would like to break on finding an invalid card, enter y, if you want to continue when finding an invalid card, type n." << endl;

	cin >> Affirm;

	if (Affirm == 'y' || Affirm == 'Y')
	{
		Assert = true;
	}
	else if (Affirm == 'n' || Affirm == 'N')
	{
		Assert = false;
	}
	else
	{
		cout << "Sorry, you have entered an invalid answer. Please restart the program and try again" << endl;
		system("PAUSE");
	}

	return(Assert);

}

int InputCards() //returns number of cards
{
	ins.open(infile);
	int CreditCardCounter;
	CreditCardCounter = 0;

	if (ins.fail())
	{
		cout << "The file containing the card numbers could not be opened, please be sure that Numbers.txt exists in the main directory." << endl;
	}

	do
	{
		getline(ins,CreditCards[CreditCardCounter].CardNumber,'\n');

		CreditCardCounter = CreditCardCounter + 1;

		if (ins.eof())
		{
			CreditCards[0].TotalCards = CreditCardCounter;
			return(CreditCardCounter);

		}

	} while (!ins.eof());

	ins.close();

	//works up to here, 2:02 PM 11/29/14
}

string CreditCardType(int Assert)
{
	string Type;

	if (Assert == true)
	{
		if (CreditCards[CreditCards[0].TotalCards].CardNumber.at(0) == 4)
		{
			Type = "Visa";
			return(Type);
		}
		else if (CreditCards[CreditCards[0].TotalCards].CardNumber.at(0) == 5)
		{
			Type = "MasterCard";
			return(Type);
		}
		else if (CreditCards[CreditCards[0].TotalCards].CardNumber.at(0) == 3 && CreditCards[CreditCards[0].TotalCards].CardNumber.at(1) == 7)
		{
			Type = "AmericanExpress";
			return(Type);
		}
		else if (CreditCards[CreditCards[0].TotalCards].CardNumber.at(0) == 6)
		{
			Type = "Discover";
			return(Type);
		}
		else
		{
			int False;
			False = 1;
			assert(False == 2);
		}
	}
	else if (Assert == false)
	{
		if (CreditCards[CreditCards[0].TotalCards].CardNumber.at(0) == 4)
		{
			Type = "Visa";
			return(Type);
		}
		else if (CreditCards[CreditCards[0].TotalCards].CardNumber.at(0) == 5)
		{
			Type = "MasterCard";
			return(Type);
		}
		else if (CreditCards[CreditCards[0].TotalCards].CardNumber.at(0) == 3 && CreditCards[CreditCards[0].TotalCards].CardNumber.at(1) == 7)
		{
			Type = "AmericanExpress";
			return(Type);
		}
		else if (CreditCards[CreditCards[0].TotalCards].CardNumber.at(0) == 6)
		{
			Type = "Discover";
			return(Type);
		}
		else
		{
			ens.open(errorfile);

			int ErrorCount;
			ErrorCount = 1;
			
			if (ErrorCount == 1)
			{
				ens << "Invalid Card Numbers due to no known type." << endl;
				ens << CreditCards[CreditCards[0].TotalCards].CardNumber << endl;

				ErrorCount = ErrorCount + 1;
			}
			else if (!ErrorCount == 1)
			{
				ens << CreditCards[CreditCards[0].TotalCards].CardNumber << endl;
			}

		}
	}
}

void IsValid(int Assert)
{
	do
	{
		CreditCards[CreditCards[0].TotalCards].CardType = CreditCardType(Assert);

		CreditCards[0].TotalCards = CreditCards[0].TotalCards - 1;

	} while (CreditCards[0].TotalCards > 0);


}

int main()
{
	bool AssertionCheck;
	int NumberOfCards;
	int CurrentCard;

	CurrentCard = 0;

	AssertionCheck = AssertCheck();
	NumberOfCards = InputCards();
	IsValid(AssertionCheck);


	system("PAUSE");

}