#include <Car.hpp>
namespace Hagbard {
	Car::Car ( void ) {
		this->GenerateRandomInfo ( );
	}

	Car::Car ( 
		const int &Year,
		std::string &RegNumber,
		std::string &Brand
		) {
		this->__Year = 0;
		this->__RegNumber = RegNumber;
		this->__Brand = Brand;
		this->MyRand = new Random ( );
	}

	Car::Car ( Car &Old ) {
		this->__Year = Old.GetYear ( );
		this->__RegNumber = Old.GetRegNumber ( );
		this->__Brand = Old.GetBrand ( );
		this->MyRand = new Random ( );
	}

	Car::~Car ( void ) {
		std::cout << "A car was deleted." << std::endl;
	}

	int Car::GetYear ( void ) {
		return this->__Year;
	}

	void Car::SetYear ( const int &Year ) {
		this->__Year = Year;
	}

	std::string Car::GetRegNumber ( void ) {
		return this->__RegNumber;
	}

	void Car::SetRegNumber ( std::string &RegNumber ) {
		this->__RegNumber = RegNumber;
	}

	std::string Car::GetBrand ( void ) {
		return this->__Brand;
	}

	void Car::SetBrand ( std::string &Brand ) {
		this->__Brand = Brand;
	}

	void Car::PrintInfo ( void ) {
		std::cout << "Brand: " << this->__Brand << std::endl;
		std::cout << "Year: " << this->__Year << std::endl;
		std::cout << "Reg number: " << this->__RegNumber << std::endl;
	}

	void Car::GenerateRandomInfo ( void ) {
		this->GenerateRandomBrand ( );
		this->GenerateRandomRegNumber ( );
		this->GenerateRandomYear ( );
	}

	void Car::GenerateRandomBrand ( void ) {
		switch ( this->MyRand->NextInt ( 0, 5 ) ) {
			case 0:
				this->__Brand = "Volvo";
				break;

			case 1:
				this->__Brand = "Ford";
				break;

			case 2:
				this->__Brand = "Opel";
				break;

			case 3:
				this->__Brand = "Saab";
				break;

			case 4:
				this->__Brand = "Nissan";
				break;

			case 5:
				this->__Brand = "Toyota";
				break;
		}
	}

	void Car::GenerateRandomRegNumber ( void ) {
		char RegNumber[6];

		for ( int i = 0; i < 6; i++ ) {
			if ( i > 2 )
				RegNumber[i] = (char)(this->MyRand->NextInt ( 48, 57 ));
			if ( i < 3 )
				RegNumber[i] = (char)(this->MyRand->NextInt ( 65, 90 ));
		}
		this->__RegNumber.empty ( );
		this->__RegNumber.insert ( 0, RegNumber );
	}

	void Car::GenerateRandomYear ( void ) {
		this->__Year = this->MyRand->NextInt ( 1950, 2007 );
	}

	std::ostream & operator<< ( std::ostream & os, const Car & car ) {
		os << "Brand: " << car.__Brand << std::endl
			<< "Year: " << car.__Year  << std::endl
			<< "Reg number: " << car.__RegNumber << std::endl;
		return os;
	}

} /* namespace Hagbard */
#ifndef _CAR_HPP
#define _CAR_HPP

#include <string>
#include <iostream>
#include <Random.hpp>

namespace Hagbard {
	class Car {
	private:
		int __Year;
		std::string __RegNumber;
		std::string __Brand;
		Random *MyRand;

	public:
		/* Constructors/Destructors */
		Car ( void );
		Car ( 
			const int &Year,
			std::string &RegNumber,
			std::string &Brand
		);
		Car ( Car &Old );
		~Car ( void );

		/* Get/Sets */
		int GetYear ( void );
		void SetYear ( const int &Year );

		std::string GetRegNumber ( void );
		void SetRegNumber ( std::string &RegNumber );

		std::string GetBrand ( void );
		void SetBrand ( std::string &Brand );

		/* Print some info... */
		void PrintInfo ( void );

		/* Generate brand, regnumber and year. */
		void GenerateRandomInfo ( void );
		void GenerateRandomBrand ( void );
		void GenerateRandomRegNumber ( void );
		void GenerateRandomYear ( void );

		/* Print functions. */
		friend std::ostream & operator<< ( std::ostream & os, const Car & car );
	};
} /* namespace Hagbard */
#endif
#include <iostream>
#include <Car.hpp>

#define LENGTH 10

int main ( int argc, char **argv ) {
	Hagbard::Car **Cars = new Hagbard::Car*[LENGTH];
	for ( int i = 0; i < LENGTH; i++ )
		Cars[i] = new Hagbard::Car ( );

	for ( int i = 0; i < LENGTH; i++ )
		std::cout << **(Cars + i);

	delete [] Cars;
	return 0;
}
#include <Random.hpp>

namespace Hagbard {
	Random::Random ( void ) {
	}

	Random::~Random ( void ) {
		/* Make me deleteable. */
	}

	unsigned int Random::NextInt ( unsigned int Min, unsigned int Max ) {
		if ( Min > Max ) return (unsigned int)0;

		unsigned int Number;
		do {
			Number = (unsigned int) rand ( ) % ( Max + 1 );
		} while ( Number < Min );
		return Number;
	}

	unsigned int Random::NextInt ( unsigned int Max ) {
		return this->NextInt ( INT_MIN, Max );
	}

	unsigned int Random::NextInt ( void ) {
		return this->NextInt ( INT_MIN, INT_MAX );
	}
} /* namespace Hagbard */
#ifndef _RANDOM_HPP
#define _RANDOM_HPP

#include <ctime>
#include <cstdio>
#include <cstdlib>
#include <climits>

namespace Hagbard {
	class Random {
	public:
		Random ( void );
		~Random ( void );

		unsigned int NextInt ( unsigned int Min, unsigned int Max );
		unsigned int NextInt ( unsigned int Max );
		unsigned int NextInt ( void );
	};
}
#endif