#include <iostream>
#include <fstream>
#include "MyLink.h"



// redis hash function
unsigned int dictGenHashFunction(const  char *buf, int len) {
    unsigned int hash = 5381;

    while (len--)
        hash = ((hash << 5) + hash) + (*buf++);
    return hash;
}

int main()
{
    MyLink bucket[7];

    std::ifstream infstream("OutData.dat");
    std::string key, value, tmp;
    while (std::getline(infstream, key) &&
        std::getline(infstream, value) &&
        std::getline(infstream, tmp)) {
        unsigned int hashNum = dictGenHashFunction(key.c_str(), key.size());
        bucket[hashNum % 7].AppendNode(key, value);
    }

    for (int i = 0; i < 7; i++) {
        std::cout << "bucket[" << i << "] has " << bucket[i].GetNodeCount() << " nodes" << std::endl;
    }


    return 0;
}

#pragma once

#include <memory>
#include <string>



class MyLink {
private:
	struct LinkNode {
		std::string key_;
		std::string value_;
		std::shared_ptr<LinkNode> next_;
		std::shared_ptr<LinkNode> prev_;
	};
public:
	MyLink() :head_(nullptr), tail_(nullptr), nodeCount_(0){}
	MyLink(std::string key,std::string value){
		head_ = tail_ = InitNode(key,value);
		nodeCount_ = 1;
	}

	~MyLink() {
		if (head_ == nullptr) {
			return;
		}
		while (head_ != nullptr) {
			std::shared_ptr<LinkNode> p = head_;
			if (p->next_ == nullptr) {
				head_ = tail_ = nullptr;
				nodeCount_--;
				break;
			}
			head_ = p->next_;
			p->next_ = nullptr;
			head_->prev_ = nullptr;
			nodeCount_--;
		}
	}

	size_t GetNodeCount() {return nodeCount_;}

	void PrintNode() {
		std::shared_ptr<LinkNode> p = head_;
		for (; p != nullptr; p = p->next_) {
			std::cout << p->key_ << " " << p->value_ << std::endl;
		}
		std::cout << std::endl;
	}

	std::shared_ptr<LinkNode> FindNode(const std::string key,const std::string value) {
		std::shared_ptr<LinkNode> p = nullptr;
		if (nullptr == tail_ || nullptr == head_) {
			return p;
		}

		for (std::shared_ptr<LinkNode> p = head_; p != nullptr; p = p->next_) {
			if (p->key_ == key && p->value_ == value )
				return p;
		}

		return nullptr;
	}


	std::shared_ptr<LinkNode> FindNode(std::shared_ptr<LinkNode> node) {
		std::shared_ptr<LinkNode> p = nullptr;
		if (node == nullptr)
			return p;
		if (nullptr == tail_ || nullptr == head_) {
			return p;
		}

		for (std::shared_ptr<LinkNode> p = head_; p != nullptr; p = p->next_) {
			if (p->key_ == node->key_ && p->value_ == node->value_)
				return p;
		}
		
		return nullptr;
	}

	bool DeleteNode(const std::string key, const std::string value) {
		std::shared_ptr<LinkNode>p = FindNode(key, value);
		if ( p  == nullptr  ) {
			return false;
		}
		if (p->prev_ == nullptr && p->next_ == nullptr) {
			head_ =  tail_ = nullptr;	
		}else if (p->prev_ == nullptr) {
			head_ = p->next_;
			p->next_ = nullptr;
			head_->prev_ = nullptr;
		}
		else if (p->next_ == nullptr) {
			tail_ = p->prev_;
			tail_->next_ = nullptr;
			p->prev_ = nullptr;
		}else {
			p->prev_->next_ = p->next_;
			p->next_->prev_ = p->prev_;
			p->prev_ = p->next_ = nullptr;
		}
		nodeCount_--;
		return true;
	}

	bool DeleteNode(std::shared_ptr<LinkNode>& node) {
		std::shared_ptr<LinkNode>p = FindNode(node);
		if (p == nullptr) {
			return false;
		}
		if (p->prev_ == nullptr && p->next_ == nullptr) {
			head_ = tail_ = nullptr;
		}
		else if (p->prev_ == nullptr) {
			head_ = p->next_;
			p->next_ = nullptr;
			head_->prev_ = nullptr;
		}
		else if (p->next_ == nullptr) {
			tail_ = p->prev_;
			tail_->next_ = nullptr;
			p->prev_ = nullptr;
		}
		else {
			p->prev_->next_ = p->next_;
			p->next_->prev_ = p->prev_;
			p->prev_ = p->next_ = nullptr;
		}
		nodeCount_--;
		return true;
	}

	bool AppendNode(std::string key, std::string value) {

		return AppendNode(InitNode(key,value));
	}

	bool AppendNode(std::shared_ptr<LinkNode> node) {
		bool ret = false;
		if (nullptr == head_  && nullptr  == tail_) {
			head_ = tail_ = node;
			nodeCount_++;
			ret = true;
			return ret;
		}
		else if (nullptr == tail_ || nullptr == head_) {
			return ret;
		}
		
		tail_->next_ = node;
		node->prev_ = tail_;
		tail_ = node;
		node->next_ = nullptr;
		nodeCount_++;

		ret = true;
		return ret;
	}

	static std::shared_ptr<LinkNode> InitNode(const std::string& key, const std::string& value) {
		std::shared_ptr<LinkNode> p(new LinkNode);
		p->key_ = key;
		p->value_ = value;
		p->next_ = nullptr;
		p->prev_ = nullptr;
		return p;
	}
private:
	

	MyLink(const MyLink&);
	const MyLink& operator=(const MyLink&);
	size_t nodeCount_;
	std::shared_ptr<LinkNode> head_;
	std::shared_ptr<LinkNode> tail_;
};