// Copyright 2019 [BVU CMSC491 class]
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <cmath>
#include "SPE.h"
#include "TCPListener.h"
#include "MinecraftRegionLoader.h"


TCPListener listener;

struct aggData {
  float chunkVal;
  pos chunkID;
  std::vector<pos>* oreLocations;
} typedef aggData;


float calcDistance(pos playerPos, pos chunkPos) {
  float x = pow(playerPos.x - chunkPos.x, 2);
  float y = pow(playerPos.y - chunkPos.y, 2);
  float z = pow(playerPos.z - chunkPos.z, 2);
  float dist = sqrt(x+y+z);
  return dist;
}


pos getBlockPos(int i, pos globalChunkPos) {
  //i = y*16*16 + z*16 + x
  pos p;
  int relx, rely, relz, diff;

  rely = i/256;
  diff = i-(rely*256);
  relx = diff % 16;
  relz = (diff - relx)/16;

  p.y = rely + globalChunkPos.y;
  p.z = relz + globalChunkPos.z;
  p.x = relx + globalChunkPos.x;

  return p;
}


class ChunkSelect : public Operator {
  public:
    ChunkSelect(int r, int s) : Operator(r, s) {}
    void processData(Data data) {
      std::cout << "chunk select recv one data" << std::endl;
      emit(Data(&data, sizeof(aggData)));
      std::cout << "chunk select emit data" << std::endl;
    }

    void processData() {
      std::cout << "chunk select recv data" << std::endl;
      aggData bestAgg;
      bestAgg.chunkVal = -1;
      for (Data d : window) {
        if(bestAgg.chunkVal == -1 || bestAgg.chunkVal < (*(aggData*)d.value).chunkVal ) {
          if(bestAgg.chunkVal != -1) {
            delete bestAgg.oreLocations;
          }
          bestAgg = *(aggData*)(d.value);
        }
        else {
          delete (*(aggData*)d.value).oreLocations;
        }
      }

      std::cout << "chunk select emit data" << std::endl;
      emit(Data(&bestAgg, sizeof(aggData)));
    }
};


class ChunkProcessor : public Operator {
  public:
    void processData(Data data) {
      //std::cout << "chunk procesessor recv data" << std::endl;
      ChunkData &chunk = *(ChunkData*)data.value;

      // Handle an empty chunk
      if (chunk.empty == true) {
        aggData dataToPass;
        dataToPass.oreLocations = new std::vector<pos>
        dataToPass.chunkVal = 0;
         
        //std::cout << "[empty] chunk procesessor emit data" << std::endl;
        emit(Data(&dataToPass, sizeof(aggData)));
        return;
      }

      // Handle an non-empty chunk
      float count = 0;
      aggData dataToPass;
      std::vector<pos>* oreLocations = new std::vector<pos>
      dataToPass.chunkID = chunk.globalChunkPos;

      dataToPass.oreLocations = oreLocations;
      for(int i = 0; i<65536 ; i++) {
        if(chunk.chunk[i] == chunk.oreID){
          count++;
          oreLocations->push_back(getBlockPos(i, chunk.globalChunkPos));
        }
      }

      dataToPass.chunkVal = count/calcDistance(chunk.playerPos, chunk.globalChunkPos);

      //std::cout << "[non-empty] chunk procesessor emit data with #ores:" << oreLocations->size() << std::endl;
      emit(Data(&dataToPass, sizeof(aggData)));
    }
};


class Generator : public InputSource {
  void generateData() {

    std::cout << "Waiting for data from mod..." << std::endl;

    std::string strPos;
    while ( (strPos = listener.GetLine()) != "") {
      std::istringstream is(strPos);
      pos playerPos;
      is >> playerPos.x >> playerPos.y >> playerPos.z;
      std::cout << "Player pos at: " <<
        playerPos.x << " " <<
        playerPos.y << " " <<
        playerPos.z << std::endl;

      //pos playerPos = {0,0,0};
      MinecraftRegionLoader loader(playerPos);
      std::vector<ChunkData*> chunks = loader.extractChunkData();

      for(int i=0; i < chunks.size(); i++) {
        chunks[i]->oreID = 26;
        emit(Data(chunks[i], sizeof(ChunkData)));
      }

      std::cout << "Produced " << chunks.size() << "chunks. Waiting for more data from mod..." << std::endl;
    }

    std::cout << "Minecraft Mod Disconnected" << std::endl;
  }
};


class PrintOp : public Operator{
  public:
    void processData(Data data){

      //std::cout << "chunk print recv data" << std::endl;
      aggData bestChunk = *(aggData*)data.value;
      std::vector<pos> ores = *(bestChunk.oreLocations);
      //std::cout << "ores size: " << ores.size() << std::endl;
      for(int i=0; i<ores.size(); i++){
       std::cout <<"Chunk: " << bestChunk.chunkID.x << " " << bestChunk.chunkID.z << " " << bestChunk.chunkID.y << std::endl;
       std::cout <<"Desired Ore at pos: " << std::endl;
       std::cout << "x: " << ores[i].x << std::endl;
       std::cout << "z: " << ores[i].z << std::endl;
       std::cout << "y: " << ores[i].y << std::endl;
      }

      if (ores.empty() == false) {
        std::ostringstream os;
        os << "Get ore at " << ores[0].x << " " << ores[0].y << " " << ores[0].z;
        string msg = os.str();
        uint8_t msgSz = msg.size();

        listener.SendData((char*)&msgSz, sizeof(msgSz));
        listener.SendData(msg.c_str(), msgSz);
      }

      delete bestChunk.oreLocations;
    }
};

int main(int argc, char** argv) {
  std::cout << "SPE Starting up." << std::endl;

  int port = 12345;
  listener.Bind(port);

  std::cout << "Waiting for connection..." << std::endl;
  if (listener.WaitForConnection() <= 0) {
    std::cout << "Error - failed to connect" << std::endl;
    return 0;
  }

  Generator inputSource;
  ChunkProcessor op1;
  ChunkSelect op2(1024, 1024);
  PrintOp op3;

  StreamProcessingEngine spe;

  spe.addInputSource(&inputSource, {&op1});
  spe.connectOperators(&op1, {&op2});
  spe.connectOperators(&op2, {&op3});

  spe.run();

  std::cout << "SPE Finished." << std::endl;
  return 0;
}
				

#include <Windows.h>

#include "HeapManager.h"
#include <cassert>
#include <stdio.h>
#include <memoryapi.h>

bool IsPowerOfTwo(unsigned int x)
{
	return (x & (x - 1)) == 0;
}

inline unsigned int AlignUp(unsigned int i_value, unsigned int i_align)
{
	assert(i_align);
	assert(IsPowerOfTwo(i_align));
	return (i_value + (i_align - 1)) & ~(i_align - 1);
}

inline unsigned int AlignDown(unsigned int i_value, unsigned int i_align)
{
	assert(i_align);
	assert(IsPowerOfTwo(i_align));
	return i_value & ~(i_align - 1);
}



HeapManager::HeapManager(void* i_memStart, const size_t i_maxSize, const unsigned int i_numDescriptors) {
	unsigned int overhead = sizeof(HeapManager) + (sizeof(Descriptor) * i_numDescriptors);

	m_numDescriptors = i_numDescriptors;
	m_memStart = i_memStart;

	// Starting at beginning of total block (i_memStart), write descriptors. They are accounted for in overhead.
	m_unusedBlocks = reinterpret_cast<Descriptor*>(reinterpret_cast<char*>(i_memStart) + sizeof(HeapManager));
	Descriptor* d = m_unusedBlocks;
	for (unsigned int i = 0; i < i_numDescriptors; i++) {
		d->startAddr = nullptr;
		d->size = 0;
		d->next = d + 1;
		d++;
	}
	(d - 1)->next = nullptr; // Set the last item's next to null

	m_maxSize = i_maxSize - overhead;
	m_outstandingAllocList = nullptr;
	m_freeList = getUnusedBlock();
	m_freeList->startAddr = reinterpret_cast<char*>(i_memStart) + overhead;
	m_freeList->size = m_maxSize;
	m_freeList->next = nullptr;
}

HeapManager* HeapManager::CreateHeapManager(void* i_memStart, const size_t i_maxSize, const unsigned int i_numDescriptors) {
	assert(i_memStart != nullptr && i_maxSize > 0 && i_numDescriptors > 0);

	HeapManager* manager = reinterpret_cast<HeapManager*>(i_memStart);

	return new (manager) HeapManager(i_memStart, i_maxSize, i_numDescriptors);
}

size_t HeapManager::GetLargestFreeBlock() {
	assert(m_freeList != nullptr);
	Descriptor* d = m_freeList;

	size_t maxSize = d->size;
	while (d != nullptr) {
		maxSize = (d->size > maxSize) ? d->size : maxSize;
		d = d->next;
	}

	return maxSize;
}

void* HeapManager::alloc(size_t i_size) {
	Descriptor* d = getFirstFreeBlock(i_size, 1);

	// There is either not enough space or not enough blocks.
	if (d == nullptr)
		return nullptr;

	// Add to outstanding allocations
	d->next = m_outstandingAllocList;
	m_outstandingAllocList = d;

	return d->startAddr;
}


void* HeapManager::alloc(size_t i_size, int i_alignment) {
	Descriptor* d = getFirstFreeBlock(i_size, i_alignment);

	// There is either not enough space or not enough blocks.
	if (d == nullptr)
		return nullptr;

	// Add to outstanding allocations
	d->next = m_outstandingAllocList;
	m_outstandingAllocList = d;

	return d->startAddr;
}


bool HeapManager::free(void* i_addr) {
	// Nothing allocated.
	if (m_outstandingAllocList == nullptr)
		return false;

	// Check if it is first
	if (m_outstandingAllocList->startAddr == i_addr) {
		Descriptor* desc = m_outstandingAllocList;
		// remove from outstanding allocations
		m_outstandingAllocList = desc->next;

		// add into free list
		InsertToFreeList(desc);
		return true;
	}

	// Get the related descriptor
	Descriptor* prev = m_outstandingAllocList;
	Descriptor* cur = prev->next;
	while (cur != nullptr) {
		if (cur->startAddr == i_addr) {
			// Remove from outstanding allocations
			prev->next = cur->next;

			// Add into free list
			InsertToFreeList(cur);

			return true;
		}

		prev = cur;
		cur = prev->next;
	}
	
	// Not allocated address
	return false;
}

bool HeapManager::Contains(void* i_addr) {
	if (m_outstandingAllocList == nullptr)
		return false;

	Descriptor* d = m_outstandingAllocList;

	while (d != nullptr) {
		if (i_addr >= d->startAddr && i_addr <= reinterpret_cast<char*>(d->startAddr) + d->size) {
			return true;
		}

		d = d->next;
	}

	return false;
}

bool HeapManager::IsAllocated(void* i_addr) {
	if (m_outstandingAllocList == nullptr)
		return false;

	Descriptor* d = m_outstandingAllocList;

	while (d != nullptr) {
		if (d->startAddr == i_addr) {
			return true;
		}

		d = d->next;
	}

	return false;
}

/*
	Garbage collect - coalesce adjacent blocks
*/
void HeapManager::Collect() {
	// There is nothing to combine if there is none or only one block.
	if (m_freeList == nullptr)
		return;
	if (m_freeList->next == nullptr)
		return;

	bool madeChange = true;
	while (madeChange) {
		madeChange = false;

		Descriptor* prev = m_freeList;
		Descriptor* cur = prev->next;

		while (cur != nullptr) {
			char* endPoint = reinterpret_cast<char*>(prev->startAddr) + prev->size;
			char* curStartPoint = reinterpret_cast<char*>(cur->startAddr);

			// If they are one off, then they're adjacent
			if (endPoint == curStartPoint) {
				// nom nom nom
				prev->size += cur->size;
				cur->size = 0;
				prev->next = cur->next;

				// Add cur to unused blocks
				cur->next = m_unusedBlocks;
				m_unusedBlocks = cur;

				// Move cur because now it's in unused blocks
				cur = prev;
				madeChange = true;
			}

			// Move to the next set
			prev = cur;
			cur = cur->next;
		}
	}
}


/*
	Gets the first free block that fits the given size. Removes the descriptor from free list and adds
	a new one for the remaining size. 
*/
Descriptor* HeapManager::getFirstFreeBlock(size_t i_size, int i_alignment) {
	// There is no free blocks
	if (m_freeList == nullptr)
		return nullptr;

	// If the first is large enough, allocate it (account for potentially required alignment)
	if (m_freeList->size > i_size + i_alignment) {
		Descriptor* desc = m_freeList;

		// Get an unused block, put it at the start of freeList
		m_freeList = getUnusedBlock();
		
		//if getUnusedBlock returns nullptr, revert
		if (m_freeList == nullptr) {
			m_freeList = desc;
			return nullptr;
		}

		m_freeList->startAddr = desc->startAddr;
		m_freeList->next = desc->next;

		// Move from back to front to allocate space
		char* unalignedAddr = reinterpret_cast<char*>(desc->startAddr) + desc->size - i_size;
		unsigned int movedAddr = AlignDown(reinterpret_cast<unsigned int>(unalignedAddr), i_alignment);
		desc->startAddr = reinterpret_cast<void*>(movedAddr);

		// Account for the newly aligned sizes
		m_freeList->size = reinterpret_cast<char*>(desc->startAddr) - reinterpret_cast<char*>(m_freeList->startAddr);
		desc->size = i_size + reinterpret_cast<unsigned int>(unalignedAddr) - movedAddr;

		return desc;
	}

	Descriptor* prev = m_freeList;
	Descriptor* cur = prev->next;
	while (cur != nullptr) {
		if (cur->size > i_size + i_alignment) {
			// Set up a replacement for the remaining size, set up pointers accordingly
			Descriptor* replacement = getUnusedBlock();

			// If getUnusedBlock returns nullptr, bail
			if (replacement == nullptr)
				return nullptr;

			replacement->startAddr = cur->startAddr;
			replacement->next = cur->next;

			// Move from back to front to allocate space
			char* unalignedAddr = reinterpret_cast<char*>(cur->startAddr) + cur->size - i_size;
			unsigned int movedAddr = AlignDown(reinterpret_cast<unsigned int>(unalignedAddr), i_alignment);
			cur->startAddr = reinterpret_cast<void*>(movedAddr);

			prev->next = replacement;

			// Update size and return
			cur->size = i_size + reinterpret_cast<unsigned int>(unalignedAddr) - movedAddr;
			replacement->size = reinterpret_cast<char*>(cur->startAddr) - reinterpret_cast<char*>(replacement->startAddr);
			return cur;
		}

		prev = cur;
		cur = prev->next;
	}

	// None of size
	return nullptr;
}

Descriptor* HeapManager::getUnusedBlock() {
	if (m_unusedBlocks == nullptr)
		return nullptr;

	Descriptor* o_desc = m_unusedBlocks;
	m_unusedBlocks = o_desc->next;

	return o_desc;
}


void HeapManager::ShowOutstandingAllocations() {
	Descriptor* d = m_outstandingAllocList;

	printf("Allocated List:\n");
	while (d != nullptr) {
		printf("\t selfAddr: %p \t startAddr: %p \t size:%d \t next: %p\n", d, d->startAddr, d->size, d->next);
		d = d->next;
	}
}

void HeapManager::ShowFreeBlocks() {
	Descriptor* d = m_freeList;

	printf("Free List:\n");
	while (d != nullptr) {
 		printf("\t selfAddr: %p \t startAddr: %p \t size:%d \t next: %p\n", d, d->startAddr, d->size, d->next);
		d = d->next;
	}
}

void HeapManager::InsertToFreeList(Descriptor* i_desc) {
	// Check if it is the first item
	if (m_freeList == nullptr || m_freeList->startAddr > i_desc->startAddr) {
		// push onto front
		i_desc->next = m_freeList;
		m_freeList = i_desc;

		return;
	}
	
	// Otherwise, iterate list and place in sorted order
	Descriptor* prev = m_freeList;
	Descriptor* cur = prev->next;
	while (cur != nullptr) {
		if (prev->startAddr < i_desc->startAddr && cur->startAddr > i_desc->startAddr) {
			// Place in between
			prev->next = i_desc;
			i_desc->next = cur;

			return;
		}

		prev = cur;
		cur = prev->next;
	}
	
	// Finally, if it was never placed, put it at the end
	prev->next = i_desc;
	i_desc->next = nullptr;
}


void HeapManager::Destroy() {
	VirtualFree(m_memStart, 0, MEM_RELEASE);
}