#pragma once
#include <iostream>
#include "Node.h"
#include <algorithm>
template <class T>
class BTree {
private:
	Node<T>* root;
	int t; //*B-树的阶数（节点最大元素数的一半）
	//这里的t最后体现在每个节点上都是t - 1 到 2t - 1

	void splitChild(Node<T>* _node, int _n);
	void insertNonFull(Node<T>* _node, const T& _key);
	void inorder(Node<T>* _n) {
		if (!_n) return;

		int i = 0;
		//关注中序的时候：inorder(children[0]) -> inorder(key[0]) -> inorder(children[1])... 这样保证升序
		for (i = 0; i < _n->keys.size(); i++) {
			if (i < _n->children.size())	inorder(_n->children[i]);
			std::cout << _n->keys[i] << " ";
		}
		//已经i++
		if (i < _n->children.size()) inorder(_n->children[i]);
		std::cout << std::endl;
	}
public:
	BTree() = delete;
	BTree(int _t) : t(_t), root(nullptr) {}

	void display() { inorder(root); }
	void insert(const T& _key);
	bool search(Node<T>* _node, const T& _key);
	void erase(const T& _key);
};

template<class T>
inline void BTree<T>::splitChild(Node<T>* _pt, int _i)
{
	//_pt-父节点//_i-第几个子节点//t-中间元素
	Node<T>* p = _pt->children[_i];
	Node<T>* tmp = new Node<T>(p->isLeaf);
	int mid = t - 1;
	//复制mid右侧
	for (int i = 0; i < mid; i++) {
		tmp->keys.push_back(p->keys[t + i]);
	}
	//不是叶子节点-复制孩子
	if (!p->isLeaf) {
		for (int i = 0; i < t; i++) {
			tmp->children.push_back(p->children[i + t]);
		}
	}
	T middlekey = p->keys[mid];
	//保留左侧
	p->keys.resize(mid);
	if (!p->isLeaf) p->children.resize(t);//t = mid + 1

	//增加孩子
	_pt->children.insert(_pt->children.begin() + _i + 1, tmp);
	//提取中间元素插入上面
	_pt->keys.insert(_pt->keys.begin() + _i, middlekey);
}

template<class T>
inline void BTree<T>::insertNonFull(Node<T>* _node, const T& _key)
{
	int i = _node->keys.size() - 1;
	//是叶子节点-先插入后排序O(n)
	if (_node->isLeaf) {
		_node->keys.push_back(_key);
		//向后移位
		while (i >= 0 && _node->keys[i] > _key) {
			_node->keys[i + 1] = _node->keys[i];
			i--;
		}
		_node->keys[i + 1] = _key;
	}
	//不是叶子节点，递归向下寻找叶子节点
	else {
		while (i >= 0 && _node->keys[i] > _key) {
			i--;
		}
		i++;//找到children位置
		//节点满了先分裂
		if (_node->children[i]->keys.size() == 2 * t - 1) {
			splitChild(_node, i);
			//分裂提升后可能改变关键字位置
			if (_key > _node->keys[i]) i++;
		}
		insertNonFull(_node->children[i], _key);
	}
}

template<class T>
inline void BTree<T>::insert(const T& _key)
{
	//1-树空无root
	if (!root) {
		root = new Node<T>(true);
		root->keys.push_back(_key);
	}
	//2-有root正常插入
	else {
		//root满，分裂根节点
		//重点关注:插入的时候，不管关键字是否上升到根节点，如果根节点满了，都要分裂以防万一
		if (root->keys.size() == 2*t - 1) {
			Node<T>* _root = new Node<T>(false);
			_root->children.push_back(root);
			splitChild(_root, 0);
			root = _root;
		}
		//继续执行
		insertNonFull(root, _key);
	}
	//当 t = 2，root 目前有 2 个元素，插入一个新元素后，root 会变成 3 个元素（满节点）。此时还不会分裂，分裂逻辑只在下一次插入超过 3 个元素时触发。
}

template<class T>
inline bool BTree<T>::search(Node<T>* _node, const T& _key)
{
	//可以递归做
	Node<T>* tmp = _node;
	int i = 0;
	while (tmp->keys[i] < _key && i < tmp->keys.size()) i++;
	if (tmp->keys[i] == _key)	return true;
	if(tmp->isLeaf)	return false;
	return search(_node->children[i], _key);
}

template<class T>
inline void BTree<T>::erase(const T& _key)
{
    if (!root) return; // 空树，直接返回

    // 用一个递归 lambda 来实现删除逻辑
    auto remove = [&](auto&& self, Node<T>* node, const T& key) -> void {
        int idx = 0;
        // 找到第一个 >= key 的位置
        while (idx < node->keys.size() && node->keys[idx] < key) idx++;

        // ==============================================================
        // 情况 1：key 存在于当前节点 node->keys[idx]
        // ==============================================================
        if (idx < node->keys.size() && node->keys[idx] == key) {
            // ---- 1.1 如果当前节点是叶子：直接删除即可
            if (node->isLeaf) {
                node->keys.erase(node->keys.begin() + idx);
            }
            // ---- 1.2 如果是内部节点（非叶子）
            else {
                Node<T>* leftChild = node->children[idx];
                Node<T>* rightChild = node->children[idx + 1];

                // ① 如果左子树至少有 t 个关键字（够借用）
                if (leftChild->keys.size() >= t) {
                    // 找到前驱（左子树最右边元素）
                    Node<T>* cur = leftChild;
                    while (!cur->isLeaf) cur = cur->children.back();
                    T pred = cur->keys.back();
                    // 用前驱替换当前 key
                    node->keys[idx] = pred;
                    // 递归去左子树删掉前驱
                    self(self, leftChild, pred);
                }
                // ② 如果右子树至少有 t 个关键字（够借用）
                else if (rightChild->keys.size() >= t) {
                    // 找到后继（右子树最左边元素）
                    Node<T>* cur = rightChild;
                    while (!cur->isLeaf) cur = cur->children.front();
                    T succ = cur->keys.front();
                    // 用后继替换当前 key
                    node->keys[idx] = succ;
                    // 递归去右子树删掉后继
                    self(self, rightChild, succ);
                }
                // ③ 左右子树都只有 t-1 个关键字，无法借 → 合并
                else {
                    // 把 key 下沉到左子树
                    leftChild->keys.push_back(node->keys[idx]);
                    // 把右子树的 keys 全部并入左子树
                    leftChild->keys.insert(leftChild->keys.end(),
                        rightChild->keys.begin(), rightChild->keys.end());
                    // 如果不是叶子，还要把右子树的 children 并过去
                    if (!leftChild->isLeaf) {
                        leftChild->children.insert(leftChild->children.end(),
                            rightChild->children.begin(), rightChild->children.end());
                    }
                    // 删除父节点中的 key 和右子树指针
                    node->keys.erase(node->keys.begin() + idx);
                    node->children.erase(node->children.begin() + idx + 1);
                    delete rightChild;
                    // 继续在合并后的左子树中删除 key
                    self(self, leftChild, key);
                }
            }
        }
        // ==============================================================
        // 情况 2：key 不在当前节点 → 去子树里找
        // ==============================================================
        else {
            if (node->isLeaf) return; // 到叶子还没找到，说明树里没有，直接返回

            bool flag = (idx == node->keys.size()); // key 比所有节点都大 → 在最后一个孩子
            Node<T>* child = node->children[idx];

            // ----------------------------------------------------------
            // 删除之前要保证 child 至少有 t 个关键字（否则可能删完不合法）
            // ----------------------------------------------------------
            if (child->keys.size() < t) {
                Node<T>* leftSibling = (idx > 0 ? node->children[idx - 1] : nullptr);
                Node<T>* rightSibling = (idx < node->keys.size() ? node->children[idx + 1] : nullptr);

                // ① 如果左兄弟存在且有 >= t 个关键字 → 向左兄弟借
                if (leftSibling && leftSibling->keys.size() >= t) {
                    // 父节点下移一个 key 给 child
                    child->keys.insert(child->keys.begin(), node->keys[idx - 1]);
                    // 左兄弟最后一个 key 上移到父节点
                    node->keys[idx - 1] = leftSibling->keys.back();
                    leftSibling->keys.pop_back();
                    // 如果有子节点，别忘了调整 children
                    if (!leftSibling->isLeaf) {
                        child->children.insert(child->children.begin(), leftSibling->children.back());
                        leftSibling->children.pop_back();
                    }
                }
                // ② 如果右兄弟存在且有 >= t 个关键字 → 向右兄弟借
                else if (rightSibling && rightSibling->keys.size() >= t) {
                    // 父节点下移一个 key 给 child
                    child->keys.push_back(node->keys[idx]);
                    // 右兄弟第一个 key 上移到父节点
                    node->keys[idx] = rightSibling->keys.front();
                    rightSibling->keys.erase(rightSibling->keys.begin());
                    // 如果有子节点，别忘了调整 children
                    if (!rightSibling->isLeaf) {
                        child->children.push_back(rightSibling->children.front());
                        rightSibling->children.erase(rightSibling->children.begin());
                    }
                }
                // ③ 左右兄弟都不足 t → 合并
                else {
                    if (leftSibling) {
                        // 把父节点一个 key 下移到左兄弟
                        leftSibling->keys.push_back(node->keys[idx - 1]);
                        // 把 child 的 keys 全部并到左兄弟
                        leftSibling->keys.insert(leftSibling->keys.end(),
                            child->keys.begin(), child->keys.end());
                        if (!child->isLeaf) {
                            leftSibling->children.insert(leftSibling->children.end(),
                                child->children.begin(), child->children.end());
                        }
                        // 父节点删除 key 和 child 指针
                        node->keys.erase(node->keys.begin() + idx - 1);
                        node->children.erase(node->children.begin() + idx);
                        delete child;
                        child = leftSibling;
                    }
                    else if (rightSibling) {
                        // 把父节点一个 key 下移到 child
                        child->keys.push_back(node->keys[idx]);
                        // 把右兄弟的 keys 全部并入 child
                        child->keys.insert(child->keys.end(),
                            rightSibling->keys.begin(), rightSibling->keys.end());
                        if (!rightSibling->isLeaf) {
                            child->children.insert(child->children.end(),
                                rightSibling->children.begin(), rightSibling->children.end());
                        }
                        node->keys.erase(node->keys.begin() + idx);
                        node->children.erase(node->children.begin() + idx + 1);
                        delete rightSibling;
                    }
                }
            }
            // ----------------------------------------------------------
            // 保证 child 至少有 t 个 key 后，递归下去
            // ----------------------------------------------------------
            if (flag && idx > node->keys.size())
                self(self, node->children[idx - 1], key);
            else
                self(self, node->children[idx], key);
        }
        };

    // 调用删除逻辑
    remove(remove, root, _key);

    // ==============================================================
    // 删除后可能导致根节点为空
    // 需要调整：如果 root 没有 key 了
    // ==============================================================
    if (root->keys.empty()) {
        Node<T>* oldRoot = root;
        // 如果 root 是叶子 → 整棵树为空
        if (root->isLeaf) root = nullptr;
        else root = root->children[0]; // root 的唯一孩子成为新的根
        delete oldRoot;
    }
}