#ifndef CONTACT_HPP
#define CONTACT_HPP

#include <cstring>

#include "CharArrayHelpers.hpp"

using std::strcpy;
using std::cout;
using std::endl;

namespace MyStructures

{

	class Contact
	{
	public:
		Contact();
		~Contact();

		Contact(const Contact& copy)noexcept(false);
		Contact& operator=(const Contact& rhs)noexcept(false);

		Contact(Contact&& move) noexcept;
		Contact& operator=(Contact&& rhs) noexcept;

		void Print();

		const char* FirstName() const;
		void FirstName(char* firstName);
		void FirstName(const char* firstName) const;

		const char* LastName() const;
		void LastName(char* lastName);
		void LastName(const char* lastName) const;

		const char* StreetAddress() const;
		void StreetAddress(char* streetAddress);
		void StreetAddress(const char* streetAddress)const;

		const char* City() const;
		void City(char* city);
		void City(const char* City)const;

		const char* State() const;
		void State(char* state);
		void State(const char* state)const;

		const char* Email() const;
		void Email(char* email);
		void Email(const char* email)const;

		int Zip() const;
		void Zip(int zip);

		bool operator!=(const Contact& rhs) const;
		bool operator==(const Contact& rhs) const;

		void Delete();

	private:
		char* firstName_{ new char[MAX_CHAR] };
		char* lastName_{ new char[MAX_CHAR] };
		char* streetAddress_{ new char[MAX_CHAR] };
		char* city_{ new char[MAX_CHAR] };
		char* state_{ new char[MAX_CHAR] };
		char* email_{ new char[MAX_CHAR] };
		int zip_{ 0 };



	};


	inline Contact::Contact()
	{
		memset(firstName_, 0, MAX_CHAR);

		memset(lastName_, 0, MAX_CHAR);

		memset(streetAddress_, 0, MAX_CHAR);

		memset(city_, 0, MAX_CHAR);

		memset(state_, 0, MAX_CHAR);

		memset(email_, 0, MAX_CHAR);

	}


	inline Contact::~Contact()
	{
		delete[] firstName_;
		delete[] lastName_;
		delete[] streetAddress_;
		delete[] city_;
		delete[] state_;
		delete[] email_;
	}

	inline Contact::Contact(const Contact& copy) noexcept(false)
	{
		OverwriteCharArray(firstName_, copy.firstName_);
		OverwriteCharArray(lastName_, copy.lastName_);
		OverwriteCharArray(streetAddress_, copy.streetAddress_);
		OverwriteCharArray(city_, copy.city_);
		OverwriteCharArray(state_, copy.state_);
		OverwriteCharArray(email_, copy.email_);
		zip_ = copy.zip_;
	}


	inline Contact& Contact::operator=(const Contact& rhs) noexcept(false)
	{
		if (this != &rhs)
		{
			OverwriteCharArray(firstName_, rhs.firstName_);
			OverwriteCharArray(lastName_, rhs.lastName_);
			OverwriteCharArray(streetAddress_, rhs.streetAddress_);
			OverwriteCharArray(city_, rhs.city_);
			OverwriteCharArray(state_, rhs.state_);
			OverwriteCharArray(email_, rhs.email_);
			zip_ = rhs.zip_;
		}
		return *this;
	}


	inline Contact::Contact(Contact&& move) noexcept
	{
		*this = std::move(move);
	}


	inline Contact& Contact::operator=(Contact&& rhs) noexcept
	{
		if (this != &rhs)
		{
			firstName_ = rhs.firstName_;
			lastName_ = rhs.lastName_;
			streetAddress_ = rhs.streetAddress_;
			city_ = rhs.city_;
			state_ = rhs.state_;
			email_ = rhs.email_;
			zip_ = rhs.zip_;
		}
	}


	inline void Contact::Print()
	{
		cout << firstName_ << " , " << lastName_ << endl;
		cout << streetAddress_ << endl;
		cout << city_ << " , " << state_ << " " << zip_ << endl << endl;
	}


	inline const char* Contact::FirstName() const
	{
		return firstName_;
	}


	inline void Contact::FirstName(char* firstName)
	{
		firstName_ = firstName;
	}


	inline void Contact::FirstName(const char* firstName) const
	{
		OverwriteCharArray(firstName_, firstName);
	}


	inline const char* Contact::LastName() const
	{
		return lastName_;
	}


	inline void Contact::LastName(char* lastName)
	{
		lastName_ = lastName;
	}


	inline void Contact::LastName(const char* lastName) const
	{
		OverwriteCharArray(lastName_, lastName);
	}


	inline const char* Contact::StreetAddress() const
	{
		return nullptr;
	}

	inline void Contact::StreetAddress(char* streetAddress)
	{
		streetAddress_ = streetAddress;
	}


	inline void Contact::StreetAddress(const char* streetAddress) const
	{
		OverwriteCharArray(streetAddress_, streetAddress);
	}


	inline const char* Contact::City() const
	{
		return city_;
	}

	inline void Contact::City(char* city)
	{
		city_ = city;
	}


	inline void Contact::City(const char* city) const
	{
		OverwriteCharArray(city_, city);
	}


	inline void Contact::State(const char* state) const
	{
		OverwriteCharArray(state_, state);
	}


	inline void Contact::Email(const char* email) const
	{
		OverwriteCharArray(email_, email);
	}


	inline const char* Contact::State()  const
	{
		return state_;
	}


	inline void Contact::State(char* state)
	{
		state_ = state;
	}


	inline const char* Contact::Email() const
	{
		return email_;
	}


	inline void Contact::Email(char* email)
	{
		email_ = email;
	}


	inline int Contact::Zip() const
	{
		return zip_;
	}


	inline void Contact::Zip(int zip)
	{
		zip_ = zip;
	}

	inline bool Contact::operator!=(const Contact& rhs) const
	{
		if (std::strcmp(firstName_, rhs.firstName_) != 0) { return true; }
		if (std::strcmp(lastName_, rhs.lastName_) != 0) { return true; }
		if (std::strcmp(streetAddress_, rhs.streetAddress_) != 0) { return true; }
		if (std::strcmp(city_, rhs.city_) != 0) { return true; }
		if (std::strcmp(state_, rhs.state_)!= 0) { return true; }
		if (std::strcmp(email_, rhs.email_) != 0) { return true; }
		if (zip_ != rhs.zip_) { return true; }

		return false;

	}
	inline bool Contact::operator==(const Contact& rhs) const
	{
		if (std::strcmp(firstName_, rhs.firstName_) != 0) { return false; }
		if (std::strcmp(lastName_, rhs.lastName_) != 0) { return false; }
		if (std::strcmp(streetAddress_, rhs.streetAddress_) != 0) { return false; }
		if (std::strcmp(city_, rhs.city_) != 0) { return false; }
		if (std::strcmp(state_, rhs.state_) != 0) { return false; }
		if (std::strcmp(email_, rhs.email_) != 0) { return false; }
		if (zip_ != rhs.zip_) { return true; }

		return true;
	}


	inline void Contact::Delete()
	{
		memset(firstName_, 0, MAX_CHAR);

		memset(lastName_, 0, MAX_CHAR);

		memset(streetAddress_, 0, MAX_CHAR);

		memset(city_, 0, MAX_CHAR);

		memset(state_, 0, MAX_CHAR);

		memset(email_, 0, MAX_CHAR);
	}


}
#endif