/**

  * RGB assembler

  * Copyright © 2017 František Kučera (frantovo.cz)

  *

  * This program is free software: you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation, either version 3 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program. If not, see <http://www.gnu.org/licenses/>.

  */

 #pragma once

 #include "types.h"

 class Memory {

 private:

 	template<typename T> T logMemoryError(const address_t &index) {

 		wprintf(L"memory error: index = %d, sizeof(T) = %d, MEMORY_SIZE = %d\n", index, sizeof (T), memorySize);

 		// TODO: return error value or throw exception

 		return T();

 	}

 	octet_t * memory;

 	address_t memorySize;

 	address_t index;

 public:

 	Memory(const address_t memorySize) {

 		this->memory = (octet_t*) malloc(memorySize);

 		this->memorySize = memorySize;

 		this->index = 0;

 	}

 	virtual ~Memory() {

 		free(memory);

 		memory = nullptr;

 	}

 	/**

 	 * Reads data on current position in memory and increments the index (position).

 	 * @return value found at current position

 	 */

 	template<typename T> T read() {

 		// TODO: map higher memory to static hardcoded areas or peripherals

 		if (index + sizeof (T) <= memorySize) {

 			T * value = reinterpret_cast<T*> (memory + index);

 			index += sizeof (T);

 			return *value;

 		} else {

 			return logMemoryError<T>(index);

 		}

 	}

 	/**

 	 * Reads data on given position in memory (without affecting the current position).

 	 * @return value found at given position

 	 */

 	template<typename T> T read(const address_t &address) {

 		// TODO: map higher memory to static hardcoded areas or peripherals

 		if (address + sizeof (T) <= memorySize) {

 			return *(reinterpret_cast<T*> (memory + address));

 		} else {

 			return logMemoryError<T>(address);

 		}

 	}

 	/**

 	 * Writes data to current position in memory and increments the index (position).

 	 * @param value value to be written at current position

 	 */

 	template<typename T> T write(const T value) {

 		if (index + sizeof (T) <= memorySize) {

 			T * m = reinterpret_cast<T*> (memory + index);

 			*m = value;

 			index += sizeof (value);

 		} else {

 			return logMemoryError<T>(index);

 		}

 	}

 	/**

 	 * Writes data to given position in memory (without affecting the current position).

 	 * @param value value to be written at given position

 	 */

 	template<typename T> T write(const address_t &address, const T value) {

 		if (address + sizeof (T) <= memorySize) {

 			T * m = reinterpret_cast<T*> (memory + address);

 			*m = value;

 		} else {

 			return logMemoryError<T>(address);

 		}

 	}

 	/**

 	 * Set current addres to given position.

 	 * @param index

 	 */

 	void setAddress(address_t &index) {

 		this->index = index;

 	}

 	/**

 	 * @return Current position in the memory.

 	 */

 	address_t getAddress() {

 		return index;

 	}

 	/**

 	 * @return whether the current position is inside the memory boundaries = still processing.

 	 */

 	bool isNotOver() {

 		return index < memorySize;

 	}

 	/**

 	 * Set current position to the start of the memory = position 0.

 	 */

 	void setAddressToBeginning() {

 		index = 0;

 	}

 	/**

 	 * Set current position behind the end of the memory = stop processing.

 	 */

 	void setAddressToEnd() {

 		index = memorySize;

 	}

 };