#pragma once

#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <string>
#include <memory>
#include <chrono>

#include "../utils/vp_semaphore.h"
#include "../utils/vp_utils.h"
#include "../utils/logger/vp_logger.h"
#include "vp_meta_publisher.h"
#include "vp_meta_hookable.h"
#include "../objects/vp_control_meta.h"
#include "../objects/vp_frame_meta.h"
#include "../excepts/vp_invalid_calling_error.h"

namespace vp_nodes {
    // node type
    enum vp_node_type {
        SRC,  // src node, must not have input branchs
        DES,  // des node, must not have output branchs
        MID   // middle node, can have input and output branchs
    };

    // base class for all nodes
    class vp_node: public vp_meta_publisher, 
                    public vp_meta_subscriber, 
                    public vp_meta_hookable, 
                    public std::enable_shared_from_this<vp_node> {
    private:
        // previous nodes
        std::vector<std::shared_ptr<vp_node>> pre_nodes;

        // handle thread
        std::thread handle_thread;
        // dispatch thread
        std::thread dispatch_thread;

    protected:
        // alive or not for node
        bool alive = true;

        // by default we handle frame meta one by one, in some situations we need handle them batch by batch(such as vp_infer_node).
        // setting this member greater than 1 means the node will handle frame meta with batch, and vp_node::handle_frame_meta_by_batch(...) will be called other than vp_node::handle_frame_meta(...).
        // note: control meta is not allowed like above, only one by one supported.
        int frame_meta_handle_batch = 1;

        // cache input meta from previous nodes
        std::queue<std::shared_ptr<vp_objects::vp_meta>> in_queue;
        // 
        std::mutex in_queue_lock;
        // cache output meta to next nodes
        std::queue<std::shared_ptr<vp_objects::vp_meta>> out_queue;

        // synchronize for in_queue
        vp_utils::vp_semaphore in_queue_semaphore;
        // synchronize for out_queue
        vp_utils::vp_semaphore out_queue_semaphore;

        // get meta from in_queue, handle meta and put them into out_queue looply.
        // we need re-implement(define how to create meta and put it into out_queue) in src nodes since they have no previous nodes. 
        virtual void handle_run();
        // get meta from out_queue and push them to next nodes looply.
        // we need re-implement(just do nothing) in des nodes since they have no next nodes. 
        virtual void dispatch_run();

        // define how to handle frame meta [one by one], ignored in src nodes.
        // return nullptr means do not push it to next nodes, such as des nodes which have no next nodes.
        virtual std::shared_ptr<vp_objects::vp_meta> handle_frame_meta(std::shared_ptr<vp_objects::vp_frame_meta> meta);
        // define how to handle control meta, ignored in src nodes. 
        // return nullptr means do not push it to next nodes, such as des nodes which have no next nodes.
        virtual std::shared_ptr<vp_objects::vp_meta> handle_control_meta(std::shared_ptr<vp_objects::vp_control_meta> meta);

        // define how to handle frame meta [batch by batch], ignored in src nodes.
        virtual void handle_frame_meta(const std::vector<std::shared_ptr<vp_objects::vp_frame_meta>>& meta_with_batch);

        // called by child classes after all resources have been initialized (in the last constructor of chain).
        void initialized();
        // called by child classes before all resources going to be destroyed (in the last destructor of chain)。
        virtual void deinitialized();

        // push meta to the back of out_queue, then it will be pushed to next nodes in order.
        // take care it's different from vp_node::push_meta(meta) which will push meta to next nodes directly.
        // the method can be called ONLY in handle thread inside node.
        void pendding_meta(std::shared_ptr<vp_objects::vp_meta> meta);

        // protected as it can't be instanstiated directly.
        vp_node(std::string node_name);
    public:
        virtual ~vp_node();
        // clear meaningful string, such as 'file_src_0' stands for file source node at channel 0.
        std::string node_name;

        // receive meta from previous nodes, 
        // we can hook(such as modifying meta) in child class but do not forget calling vp_node.meta_flow(...) followly.
        virtual void meta_flow(std::shared_ptr<vp_objects::vp_meta> meta) override;

        // retrive current node type
        virtual vp_node_type node_type();
        
        // detach myself from all previous nodes
        void detach();
        // detach myself from specific previous nodes
        void detach_from(std::vector<std::string> pre_node_names);
        // detach myself from all previous nodes AND the same action on all next nodes(recursively), can be used to split the whole pipeline into single nodes before process exits.
        void detach_recursively();
        // attach myself to previous nodes(can be a list)
        void attach_to(std::vector<std::shared_ptr<vp_node>> pre_nodes);

        // get next nodes
        std::vector<std::shared_ptr<vp_node>> next_nodes();

        // get description of node
        virtual std::string to_string();
    };

}