#pragma once
#include <functional>
#include "sender.hpp"
#include "TemplateDispatcher.hpp"

namespace ns_mess
{
    typedef std::function<string()> StateFunc;

    class __declspec(dllexport) close_queue {}; // 用于关闭队列的消息
    class __declspec(dllexport) ChangeState  // 用于状态切换的消息
    {
        public:
            StateFunc m_chState;
            explicit ChangeState(StateFunc s) : m_chState(s) {};
    };

    class __declspec(dllexport) CDispatcher
    {
        CMyQueue* m_Queue;
        bool m_bChained;

        CDispatcher(CDispatcher const&) = delete;  // dispatcher实例不能被拷贝
        CDispatcher& operator=(CDispatcher const&) = delete;

        template<typename Dispatcher,typename Msg,typename Func>  // 允许TemplateDispatcher实例访问内部成员
        friend class CTemplateDispatcher;

        void WaitAndDispatch()
        {
            for (;;) 
            {
                auto msg = m_Queue->WaitMessage();
                DispatchMessage(msg);
            }
        }

        bool DispatchMessage(
            std::shared_ptr<MESSAGE_BASE> const& msg)
        {
            if (dynamic_cast<wrapped_message<close_queue>*>(msg.get()))
            {
                throw close_queue();
            }
            else if (dynamic_cast<wrapped_message<ChangeState>*>(msg.get()))
            {
                wrapped_message<ChangeState>* wrapper = dynamic_cast<wrapped_message<ChangeState>*>(msg.get());
                throw wrapper->contents;
            }
            return true;
        }
    public:
        CDispatcher(CDispatcher&& other) :  // dispatcher实例可以移动
            m_Queue(other.m_Queue), m_bChained(other.m_bChained)
        {
            other.m_bChained = true;  // 源不能等待消息
        }
        explicit CDispatcher(CMyQueue* q_) :
            m_Queue(q_), m_bChained(false)
        {
        }

        template<typename Message,typename Func>
        CTemplateDispatcher<CDispatcher, Message,Func>
            HandleMessage(string describe_, string clas_,string state_, Func&& func) 
        {
             return CTemplateDispatcher<CDispatcher, Message, Func>(m_Queue, this, describe_, clas_,state_, std::forward<Func>(func));
        }

        ~CDispatcher() noexcept(false)
        {
            if (!m_bChained)
            {
                WaitAndDispatch();
            }
        }
    };
}