#include <iostream>
#include <string.h>
#include <memory.h>
#include <memory>
#include <string>



#define MAX_TYPE_LEN (100)
typedef void *(func)(const std::shared_ptr<std::string> &);

class Base {
	public:
		Base(const char* type){
			 m_type = new char[MAX_TYPE_LEN];
			 strcat(m_type,type);
		}
		virtual ~Base() {
			if(m_type)
				delete m_type;
		}
		void set_type(const char* type){
			 memset(m_type,0,MAX_TYPE_LEN);
			 strcat(m_type,type);
		}
		char* get_type(){
			return m_type;
		}
	private:
		char *m_type;

};
class Sender;
class Receiver;
class Mediator {
	public:
		Mediator() = default;
		virtual ~Mediator(){}
		void set_inter(Sender * sender, Receiver * recv){
			m_sender = sender;
			m_recv = recv;
		}
		virtual void interaction() {
			std::cout << "interaction not implemented." << std::endl;
		}
	protected:
		Sender * m_sender;
		Receiver * m_recv;
};

class Sender : public Base {
	public:
		Sender(std::shared_ptr<std::string> & data, int len ,const char * type): Base(type) {
			m_data = data;
			m_len = len;
		}
		~Sender() = default;
		void set_mediator(Mediator * m){
			m_med = m;
		}
		void send() {
			if (m_med) m_med->interaction();
		}
		const std::shared_ptr<std::string> & get_data(){
			return m_data;
	   	}
	private:
		std::shared_ptr<std::string>  m_data;
		int m_len;
		Mediator * m_med;
};

class Receiver : public Base {
	public:
		Receiver(const char * type): Base(type) {}
		~Receiver()= default;
		void set_mediator(Mediator * m){
			m_med = m;
		}
		void set_recv_callback(func * f){
			m_fun = f;
		}
		std::shared_ptr<std::string> get_message(Base * b) {
          auto s  = dynamic_cast<Sender *>(b);
			if ( s != NULL)
				std::cout << this->get_type() <<  " got message from " << s->get_type() <<  std::endl;
				if (m_fun) (*m_fun)(s->get_data());
				else std::cout << "cb null" << std::endl;
			return 0;
	   	}

	private:
		Mediator * m_med;
		func *  m_fun ;
};


class ProtocolMediator: public Mediator{
	public:
		ProtocolMediator() = default;
		~ProtocolMediator() = default;
		void interaction() {
			if(m_sender && m_recv) {
				m_recv->get_message(m_sender);
			}
		}
	private:

};

void some_cbs(const std::shared_ptr<std::string> & data)
{
	std::cout <<"on yeah use_counts " << data.use_count() <<  std::endl;

	std::cout << "Got: " << *data << std::endl;
}

/*
 *sender通过mediator连接recver,sender->send最终调用了recv里注册的callback
 *sender和recver不直接打交道,而是通过meditor
 *meditor通过set_inter绑定不同的sender和recver,并且定义交互interaction
 *meditor 可实现 1对多 多对1 多对多 多种mapping方式
 */
int main(int argc , char* argv[])
{
	auto flag = std::make_shared<std::string>("bliblibliblablabla I love you");

	std::cout << "Mediator pattern mode" << std::endl;

	Sender * sender = new Sender(flag,1,"Girl");
	Receiver* recver = new Receiver("Boy");
	ProtocolMediator * meditor = new ProtocolMediator();

	sender->set_mediator(meditor);
	recver->set_mediator(meditor);

	recver->set_recv_callback((func*)(&some_cbs));

	meditor->set_inter(sender,recver);

	sender->send();
	return 0;
}

list<int>.get_iterator(); //获取该容器的iterator

void accept(Visitor* v) {
        v->visit(this); //执行访问者的动作,一般是this传入，也就是访问者来访时，是携带了自己的信息的
    }

#include <iostream>

using namespace std;
//定义两种访问者,分别访问不同的元素

class Element;
class Visitor {
	public:
		//定义可能要访问哪些元素
		virtual void visit(Element * v) = 0;
		virtual ~Visitor(){}
};
class Element {
	public:
		virtual ~Element(){}
		//定义可能有哪些访问者来访
		virtual void accept(Visitor* v) {
			v->visit(this);}
		virtual void jobA() = 0;
		virtual void jobB() = 0;
		virtual void jobC() = 0;
		//这是模板模式，叫框架模式更好
		void job_process1() { jobA();jobB();jobC();}
		void job_process2() { jobC();jobB();jobA();}
};



/** @brief ElementA
 * 某个元素的具体类,
 * 有3个工作，但是不想直接调用.通过访问者来间接使用，这样改变访问者，也改变了功能
 * */
class ElementA :public Element {

	void jobA() {cout << __func__ << endl;}
	void jobB() {cout << __func__ << endl;}
	void jobC() {cout << __func__ << endl;}
};

class ElementB :public Element {

	void jobA() {cout << __func__ << "for ElementB\n" << endl;}
	void jobB() {cout << __func__ << "for ElementB\n" << endl;}
	void jobC() {cout << __func__ << "for ElementB\n" << endl;}
};


class VisitorA :public Visitor{
	void visit(Element* e) {
		e->job_process1();
	}
};

class VisitorB :public Visitor{
	void visit(Element* e) {
		e->job_process2();
	}
};

int main(int argc , char* argv[])
{
	Element* ea = new ElementA();
	Element* eb = new ElementB();
	Visitor* va = new VisitorA();
	Visitor* vb = new VisitorB();
	ea->accept(va); //实际调用了继承的job_process1,用访问者做了一层封装
	ea->accept(vb);

	eb->accept(va);
	eb->accept(vb);
	return 0;
}

//典型的订阅行为,有改变可以通过notifyAll通知所有订阅者
Subject::notifyAll() {

    for(auto i : this->members) {
        i->notify(this->status);
    }
}

//核心就是参数传进来的sub,实现对象联动
Observer::beAttacked(Subject * sub) {
    sub->notifyAll();
}

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <memory>
#include <set>
#include <list>

/**
 *
 *
 * 博客分不同主题,
 * 不同主题下有不同的订阅者.实现以下几个目标
 *
 * 1. 订阅者本身也是文章的发布者,可以发布一篇多个主题的文章;
 * 2. 当某个主题的文章更新时,通知所有相关订阅者有新的文章;
 * 3. 订阅者 也可以 订阅多个主题的文章.
 * 4. 订阅者可以关注其他订阅者, 当其他人发表新文章时,通知自己.
 *
 *
 * */



class Observer;
class Subject;

class Article {
	public:

		void setId(int id) {article_id = id;}
		int getId() {return article_id;}

		void setTitle(std::string t) {title = t;}
		const std::string & getTitle() {return title;}

		void setAuthor(std::shared_ptr<Observer> ob) {author = ob;}
		std::shared_ptr<Observer> getAuthor() {return author;}

		void addSubjects(std::shared_ptr<Subject> subject) {
			subjects.insert(subject);
		}
		std::set<std::shared_ptr<Subject>> getSubjects() {
			return subjects;
		}

	private:
		//id
		int article_id;
		//标题
		std::string title;
		// 作者
		std::shared_ptr<Observer> author;
		//文章可以属于多个不同主题
		std::set<std::shared_ptr<Subject>> subjects;
};

class Observer;
class Subject {
	public :
		Subject(const std::string & topic): m_topic(topic){}
		virtual ~Subject(){}
		void setTopic(const std::string &  topic){
			m_topic =  topic;
		}
		//通知订阅者消息
		virtual void notifyAll() {}
		//在主题下添加了新文章
		virtual void addArticle(std::shared_ptr<Article> art) {
			m_articles.insert(
					std::make_pair(art->getId(),art)
					);
		}
		//在主题下去掉文章
		virtual void removeArticle(std::shared_ptr<Article> art) {
			auto found = m_articles.find(art->getId());
			if (found != m_articles.end()) {
				m_articles.erase(found);
			}
		}
		void addSubscriber(const Observer & ob){
			m_obs.push_back(ob);
		}
		//void removeSubscriber(const Observer & ob){
			//m_obs.remove(ob);
		//}
		const std::string & getTopic() {return m_topic;}
		std::list<Observer> getObservers() {
			return m_obs;
		}
	private:
		//谁订阅了该主题
		std::list<Observer> m_obs;
		//什么主题
		std::string m_topic;
		//发表在该主题下的文章
		std::map<int, std::shared_ptr<Article>> m_articles;
};

class Observer {
	public:
		Observer(std::string name):m_name(name) {}
		virtual ~Observer(){}
		//收到通知
		virtual void notified(std::shared_ptr<Article> art) {
			std::cout << m_name << " got new articles:(" <<
				art->getTitle() << ")" << std::endl;
		}
		//个人订阅什么主题
		virtual void subsTopic(std::shared_ptr<Subject> sub) {
			sub->addSubscriber(*this);

		}
		//个人关注的其他人
		virtual void watchSomebody(const std::shared_ptr<Observer>  & ob) {
			//把关注对象保存
			watch_objs.push_back(*ob);

			//还要把自己添加到别人的bewatched list里
			//auto & f  =  ob->getFollowLists();
			//这两个就是不同的东西, 所以并没有改变ob的followers
			auto & f = ob->followers;
			//std::cout << & ob->followers << std::endl;
			//std::cout << &f << std::endl;
			f.push_back(
					//std::shared_ptr<Observer>(this)
					std::make_shared<Observer>(*this)
					//*this
					);
			std::cout << ob->getName() << " add followers:" <<
				this->getName() << std::endl;
			std::cout << f.size() << std::endl;
		}

		void setName(const std::string & name) {m_name = name;}
		const std::string & getName() {return m_name;}

		//个人被哪些人关注.
		std::list<std::shared_ptr<Observer>> followers;
		//个人关注的其他作者
		std::list<Observer> watch_objs;
	private:
		std::string m_name;
};

//一个write, 可以发布文章到主题上
class Writer : public Observer {
	public: Writer(std::string name) : Observer(name) {}
		void pubNewArticle(std::shared_ptr<Article> article) {
			std::cout << getName() << " published a new article." << std::endl;
			std::cout << "title:
			std::cout << "===============" <<std::endl;
			auto subjects = article->getSubjects();
			//遍历文章主题
			for (auto s : subjects) {
				auto obs = s->getObservers();
				//遍历主题下对应的订阅者
				for (auto o : obs) {
					//逐个通知
					o.notified(article);
				}
			}
			//遍历我的粉丝
			std::cout << "followers size:" << followers.size() << std::endl;
			if (followers.size()) {
				std::cout << getName() <<  " has followers.." << std::endl;
			}
			for (auto f: followers) {
				f->notified(article);
			}

		}

};

//一个reader,只订阅主题,
class Reader : public Observer {
	public:
		Reader(std::string name) : Observer(name) {}
};

int main(int argc , char* argv[])
{

	auto topic_adventure =  std::make_shared<Subject>("Adventure");
	auto topic_love =  std::make_shared<Subject>("Love story");
	auto topic_travel =  std::make_shared<Subject>("Travel");

	auto hans = std::make_shared<Writer>("Mr Hans");

	auto tommy = std::make_shared<Reader>("Mr Tommy");
	tommy->subsTopic(topic_adventure);

	auto derk = std::make_shared<Reader>("Mr Derk");
	derk->subsTopic(topic_adventure);

	auto handsome = std::make_shared<Writer>("Mr Handsome");
	handsome->subsTopic(topic_adventure);
	handsome->subsTopic(topic_love);

	auto zombie = std::make_shared<Reader>("Miss Zombie");
	zombie->subsTopic(topic_adventure);
	zombie->subsTopic(topic_love);

	//僵尸小姐关注了handsome先生, 无论handsome的什么主题的文章都感兴趣..
	zombie->watchSomebody(handsome);

	auto a = std::make_shared<Article>();
	a->setId(0);
	a->setTitle("Time travel to Mars");
	a->setAuthor(hans);
	a->addSubjects(topic_adventure);


	auto b = std::make_shared<Article>();
	b->setId(1);
	b->setTitle("A black hole in sky");
	b->setAuthor(hans);
	b->addSubjects(topic_adventure);

	hans->pubNewArticle(a);
	std::cout << std::endl;
	hans->pubNewArticle(b);

	auto c = std::make_shared<Article>();
	c->setId(1);
	c->setTitle("Senven days in Chengdu");
	c->setAuthor(handsome);
	c->addSubjects(topic_travel);

	std::cout << std::endl;
	handsome->pubNewArticle(c);

	return 0;
}