#pragma once
#include <stdlib.h>
#include <unordered_map>
#include"MemoryBlock.h"
#include<iostream>
#include <assert.h>

typedef unsigned short USHORT;

const size_t MAX_BYTES = 64 * 1024; // 线程申请的最大内存
const size_t NLISTS = 184;   //数组元素总的有多少个，由对齐规则计算得来

//专门用来计算大小位置的类
class SizeClass
{
public:
	//获取Freelist的位置
	inline static size_t _Index(size_t size, size_t align)
	{
		return ((size + (1 << align) - 1) >> align) - 1;
	}

	inline static size_t _Roundup(size_t size, size_t align)
	{
		return (((size)+align - 1) & ~(align - 1));
	}

public:
	// 控制在12%左右的内碎片浪费
	// [1,128]				8byte对齐 freelist[0,16)       16
	// [129,1024]			16byte对齐 freelist[16,72)     56
	// [1025,8*1024]		128byte对齐 freelist[72,128)   56
	// [8*1024+1,64*1024]	1024byte对齐 freelist[128,184) 56

	inline static size_t Index(size_t size)
	{
		assert(size <= MAX_BYTES);

		// 每个区间有多少个链
		static int group_array[4] = { 16, 56, 56, 56 };
		if (size <= 128)
		{
			return _Index(size, 3);
		}
		else if (size <= 1024)
		{
			return _Index(size - 128, 4) + group_array[0];
		}
		else if (size <= 8192)
		{
			return _Index(size - 1024, 7) + group_array[0] + group_array[1];
		}
		else//if (size <= 65536)
		{
			return _Index(size - 8 * 1024, 10) + group_array[0] + group_array[1] + group_array[2];
		}
	}

	// 对齐大小计算，向上取整
	static inline size_t Roundup(size_t bytes)
	{
		assert(bytes <= MAX_BYTES);

		if (bytes <= 128) {
			return _Roundup(bytes, 3);
		}
		else if (bytes <= 1024) {
			return _Roundup(bytes, 4);
		}
		else if (bytes <= 8192) {
			return _Roundup(bytes, 7);
		}
		else {//if (bytes <= 65536){
			return _Roundup(bytes, 10);
		}
	}

	static size_t NumMoveSize(size_t size)
	{
		if (size == 0)
			return 0;

		int num = (int)(MAX_BYTES / size);
		if (num < 2)
			num = 2;

		if (num > 512)
			num = 512;

		return 5;
	}

};


//全局内存池为单例类。使用的时候只需要一个实例即可，并不需要多个实例。
class MemoryPool
{
private:
	//MemoryBlock* MemoryHashMap[NLISTS];
	MemoryBlock* memoryHashMap[NLISTS];//最多16中不同内存块大小，指向空闲的MemoryBlock。
	int GetSize(int);
public:
	MemoryPool();
	//分配内存
	void* Alloc(size_t);
	//释放内存。
	void FreeAlloc(void*);
	void die_free(void);
	~MemoryPool();
};


class my_share_ptr {

public:
	MemoryPool* ptr = nullptr;
	my_share_ptr(MemoryPool* _ptr = nullptr) :ptr(_ptr) {};
	my_share_ptr(const my_share_ptr& _temp) {
		this->ptr = _temp.ptr;
	}
	my_share_ptr& operator=(const my_share_ptr& _temp) {
		if (this != &_temp) {
			release();
			this->ptr = _temp.ptr;
		}
		return *this;
	}
	MemoryPool& operator*() {
		return *ptr;
	}
	MemoryPool* operator->() {
		return ptr;
	}
	~my_share_ptr() {
		release();
	}
	void release() {
		if (ptr != nullptr) {
			ptr->die_free();
			delete ptr;
			ptr = nullptr;
		}
	}
};

_declspec (thread) static my_share_ptr tlslist;