#pragma once
#include "Node.h"
#include <iostream>
#include <algorithm>

template <class T>
class BPlusTree {
private:
	Node<T>* root;
	int M;
	Node<T>* firstLeaf;//做链表范围查找

	void splitChild(Node<T>* _node, int _i);
	void insertNonFull(Node<T>* _node, const T& _key);
	void erase(Node<T>* _node, const T& _key);
	//void fixUnderflow(Node<T>* _node);没写 parent
	T& getMin(Node<T>* _node);

	void borrowLeft(Node<T>* _node, int _i);
	void borrowRight(Node<T>* _node, int _i);
	void mergeLeft(Node<T>* _node, int _i);
	void mergeRight(Node<T>* _node, int _i);

public:
	BPlusTree() = delete;
	BPlusTree(int _M) : M(_M) {
		root = new Node<T>(true);
		firstLeaf = root;
	}

	void insert(const T& _key);
	Node<T>* search(const T& _key);
	void areaSearch(const T& _low, const T& _up);
	void displayLeaf();
	void erase(const T& _key);
	
};

template<class T>
inline void BPlusTree<T>::splitChild(Node<T>* _node, int _i)
{
	Node<T>* child = _node->children[_i];
	Node<T>* newc = new Node<T>(_node->children[_i]->isLeaf);
	//中点，这个就是阶数的计算方式了，之前用t - 1 和 2t - 1
	int mid = (M - 1) / 2;
	//mid前面是左树，从mid开始往后是右树
	//拷贝元素
	newc->keys.assign(child->keys.begin() + mid, child->keys.end());
	child->keys.resize(mid);
	//拷贝孩子
	if (!child->isLeaf) {
		newc->children.assign(child->children.begin() + mid + 1, child->children.end());
		child->children.resize(mid + 1);
	}
	//更新next节点
	if (child->isLeaf) {
		newc->next = child->next;
		child->next = newc;
	}

	//比B树多的一步-更新_node，一般都是更新左（最小值）
	//区别内部外部节点
	if (!child->isLeaf) 
		//删掉newc第一个:例子-1,2,3,4,5，分为1,2;3,4,5，这时候推3，要把3从newc的第一个移除
		newc->keys.erase(newc->keys.begin());

	_node->keys.insert(_node->keys.begin() + _i, newc->keys.front());
	_node->children.insert(_node->children.begin() + _i + 1, newc);
}

template<class T>
inline void BPlusTree<T>::insertNonFull(Node<T>* _node, const T& _key)
{
	//是叶子节点直接插入
	if (_node->isLeaf) {
		auto it = std::lower_bound(_node->keys.begin(), _node->keys.end(), _key);
		_node->keys.insert(it, _key); // 插入到第一个 >= _key 的位置
	}
	//不是叶子节点接着递归寻找
	else {
		auto it = std::lower_bound(_node->keys.begin(), _node->keys.end(), _key);
		int idx = it - _node->keys.begin();
		if (_node->children[idx]->keys.size() == M - 1) {
			splitChild(_node, idx);
		}
		//插在哪边
		if (_node->keys[idx] < _key) idx++;
		insertNonFull(_node->children[idx], _key);
	}
}

template<class T>
inline void BPlusTree<T>::erase(Node<T>* _node, const T& _key)
{
	int mid = (M - 1) / 2;
	if (!search(_key)) return;
	if (!_node) return;
	//前一半和search一样
	//外部节点
	if (_node->isLeaf) {
		auto it = std::lower_bound(_node->keys.begin(), _node->keys.end(), _key);
		int idx = it - _node->keys.begin();
		if(it != _node->keys.end() && *it == _key)
			_node->keys.erase(it);
		//没事直接return
		if (root == _node || _node->keys.size() >= mid){
			return;
		}
	}
	//内部节点
	else {
		auto it = std::lower_bound(_node->keys.begin(), _node->keys.end(), _key);
		int idx = it - _node->keys.begin();
		//若在索引，先替换本值为children[idx]的第二小值
		if (it != _node->keys.end() && *it == _key) {
			*it = getMin(_node->children[idx + 1]);
		}
		erase(_node->children[idx], _key);

		//回溯的时候检查下溢，在这里检查（如果有parent节点就直接设置函数fixunderflow(_node)了）
		Node<T>* child = _node->children[idx];

		if (child->keys.size() < mid) {
			//先借
			// 借左兄弟
			if (idx > 0 && _node->children[idx - 1]->keys.size() > mid) {
				borrowLeft(_node, idx);
			}
			// 借右兄弟
			else if (idx < _node->children.size() - 1 && _node->children[idx + 1]->keys.size() > mid) {
				borrowRight(_node, idx);
			}
			// 借不到就合并
			else if (idx > 0) {
				mergeLeft(_node, idx);  // 和左兄弟合并
			}
			else if (idx < _node->children.size() - 1) {
				mergeRight(_node, idx); // 和右兄弟合并
			}
		}
	}
}
/*
template<class T>
inline void BPlusTree<T>::fixUnderflow(Node<T>* _node)
{
	//先找旁边借
	
	//借不到就合并
}*/

template<class T>
inline T& BPlusTree<T>::getMin(Node<T>* _node)
{
	if (!_node || _node->keys.empty()) {
		throw std::runtime_error("Empty node has no minimum key");
	}

	Node<T>* cur = _node;
	while (!cur->isLeaf) {
		cur = cur->children[0];  // 重点:最小的，一直往左子树走
	}
	return cur->keys[0];        // 最左叶子的第一个 key
}

template<class T>
inline void BPlusTree<T>::borrowLeft(Node<T>* _node, int _i)
{
	// 叶子节点
	if (_node->isLeaf) {
		T tmp = _node->children[_i - 1]->keys.back();
		_node->children[_i - 1]->keys.pop_back();
		_node->children[_i]->keys.insert(_node->children[_i]->keys.begin(), tmp);
		_node->keys[_i - 1] = _node->children[_i]->keys[0]; // 更新父节点分界 key
	}
	// 内部节点
	else {
		Node<T>* left = _node->children[_i - 1];
		Node<T>* cur = _node->children[_i];

		// 父节点分界 key 移到当前节点首
		cur->keys.insert(cur->keys.begin(), _node->keys[_i - 1]);

		// 左兄弟最后 key 移到父节点
		_node->keys[_i - 1] = left->keys.back();
		left->keys.pop_back();

		// 左兄弟最后子节点移到当前节点首（带着孩子一起动）
		Node<T>* c = left->children.back();
		left->children.pop_back();
		cur->children.insert(cur->children.begin(), c);
	}
}

template<class T>
inline void BPlusTree<T>::borrowRight(Node<T>* _node, int _i)
{
	// 叶子节点
	if (_node->isLeaf) {
		Node<T>* cur = _node->children[_i];
		Node<T>* right = _node->children[_i + 1];

		// 右兄弟第一个 key 移到当前节点末尾
		T tmp = right->keys.front();
		right->keys.erase(right->keys.begin());
		cur->keys.push_back(tmp);

		// 更新父节点分界 key
		_node->keys[_i] = right->keys.front();
	}
	// 内部节点
	else {
		Node<T>* cur = _node->children[_i];
		Node<T>* right = _node->children[_i + 1];

		// 父节点分界 key 移到当前节点末尾
		cur->keys.push_back(_node->keys[_i]);

		// 右兄弟第一个 key 移到父节点
		_node->keys[_i] = right->keys.front();
		right->keys.erase(right->keys.begin());

		// 右兄弟第一个子节点移到当前节点末尾
		Node<T>* c = right->children.front();
		right->children.erase(right->children.begin());
		cur->children.push_back(c);
	}
}

/*
template<class T>
inline void BPlusTree<T>::mergeLeft(Node<T>* _node, int _i)
{
	//处理父节点多出的东西
	Node<T>* c = _node->children[_i];
	_node->keys.erase(_node->keys.begin() + _i);
	//合并
	_node->children[_i - 1].insert(_node->children[_i - 1].end(), c.begin(), c.end());
	_node->children[_i - 1]->children.insert(_node->children[_i - 1]->children.end(), c->children.begin(), c->children.end());
}
*/

template<class T>
inline void BPlusTree<T>::mergeLeft(Node<T>* _node, int _i)
{
	Node<T>* left = _node->children[_i - 1];
	Node<T>* cur = _node->children[_i];

	// 1. 父节点 key 移动 / 删除
	if (!left->isLeaf) {
		// 内部节点：父节点分界 key 移到左兄弟末尾
		left->keys.push_back(_node->keys[_i - 1]);
	}
	_node->keys.erase(_node->keys.begin() + (_i - 1));

	// 2. 合并 keys
	left->keys.insert(left->keys.end(), cur->keys.begin(), cur->keys.end());

	// 3. 合并 children（仅内部节点）
	if (!left->isLeaf) {
		left->children.insert(left->children.end(), cur->children.begin(), cur->children.end());
	}

	// 4. 叶子节点更新 next 指针
	if (left->isLeaf) {
		left->next = cur->next;
	}

	// 5. 删除父节点 children 中的当前节点
	_node->children.erase(_node->children.begin() + _i);
}

template<class T>
inline void BPlusTree<T>::mergeRight(Node<T>* _node, int _i)
{
	Node<T>* cur = _node->children[_i];
	Node<T>* right = _node->children[_i + 1];

	// 1. 父节点 key
	if (!cur->isLeaf) {
		// 内部节点：父节点分界 key 移到当前节点末尾
		cur->keys.push_back(_node->keys[_i]);
	}

	// 2. 合并 keys
	cur->keys.insert(cur->keys.end(), right->keys.begin(), right->keys.end());

	// 3. 合并 children（仅内部节点）
	if (!cur->isLeaf) {
		cur->children.insert(cur->children.end(), right->children.begin(), right->children.end());
	}

	// 4. 叶子节点更新 next 指针
	if (cur->isLeaf) {
		cur->next = right->next;
	}

	// 5. 删除父节点 key
	_node->keys.erase(_node->keys.begin() + _i);

	// 6. 删除父节点 children 中的右兄弟
	_node->children.erase(_node->children.begin() + _i + 1);
}

template<class T>
inline void BPlusTree<T>::insert(const T& _key)
{
	//分裂根
	if (root->keys.size() == M - 1) {
		Node<T>* newr = new Node<T>(false);
		newr->children.push_back(root);
		splitChild(newr, 0);
		root = newr;
	}
	//插入
	insertNonFull(root, _key);
}

template<class T>
inline Node<T>* BPlusTree<T>::search(const T& _key)
{
	Node<T>* tmp = root;
	while (tmp) {
		auto it = std::lower_bound(tmp->keys.begin(), tmp->keys.end(), _key);
		int idx = it - tmp->keys.begin();

		if (tmp->isLeaf) {
			//判断是否溢出，如果范围搜索需要用到，那么均需要返回tmp，单个索引的时候再根据返回的值搜索一遍即可
			return tmp;
		}
		else {
			tmp = tmp->children[idx];
		}
	}
	return nullptr;
}

template<class T>
inline void BPlusTree<T>::areaSearch(const T& _low, const T& _up)
{
	//最好不直接用search，返回的东西不一样
	Node<T>* tmp = search(_low);
	if (!tmp) return;
	while (tmp) {
		for (auto x : tmp->keys) {
			if (x > _up) {
				std::cout << std::endl;
				return;
			}
			if (x >= _low) std::cout << x << " ";
		}
		tmp = tmp->next;
	}
	std::cout << std::endl;
}

template<class T>
inline void BPlusTree<T>::displayLeaf()
{
	Node<T>* tmp = firstLeaf;
	while (tmp) {
		for (auto x : tmp->keys) std::cout << x << " ";
		tmp = tmp->next;
		std::cout << "C ";
	}
	std::cout << std::endl;
}

template<class T>
inline void BPlusTree<T>::erase(const T& _key)
{
	if (!root) return;
	//递归删除
	erase(root, _key);
	if (root->isLeaf && root->keys.size() == 0) {
		root = root->children[0];
	}
}