#include <ndn-cxx/face.hpp>
#include <ndn-cxx/security/key-chain.hpp>
#include <ndn-cxx/security/signing-helpers.hpp>
#include <ndn-cxx/lp/tags.hpp>
#include <ndn-cxx/lp/lp-headers.hpp>
#include <iostream>

using namespace std;
// Enclosing code in ndn simplifies coding (can also use `using namespace ndn`)
namespace ndn {
// Additional nested namespaces should be used to prevent/limit name conflicts
  namespace examples {

    class Producer {
    public:
      Producer() {}

      void
      run() {
        cout << "before setInterestFilter" << endl;
        // 向NFD注册一个名称前缀 /example/testApp
        // 如果成功，NFD会在接收到以这个前缀开头的兴趣包转发给本程序，Producer::onInterest回调会被调用
        m_face.setInterestFilter("/test",
                                 bind(&Producer::onInterest, this, _1, _2),
                                 nullptr, // RegisterPrefixSuccessCallback is optional
                                 bind(&Producer::onRegisterFailed, this, _1, _2));
        cout << "before processEvents" << endl;

        // 处理NDN事件，Producer::onInterest回调是有这个函数里面调用的
        // 意味着Producer::onInterest回调会在调用 face.processEvents 的线程运行
        // 这个函数是一个阻塞函数，调用这个函数会期望处理所有相关的事件，如果向上面那样注册了前缀监听，则会一直处理事件
        m_face.processEvents();
        cout << "after processEvents" << endl;
      }

    private:
      void
      onInterest(const InterestFilter &, const Interest &interest) {
        std::cout << ">> I: " << interest << std::endl;

//        // 这边可以提取出来请求的参数
//        std::string s(reinterpret_cast<const char *>(interest.getApplicationParameters().value()),
//                      interest.getApplicationParameters().value_size());
//
//        std::cout << "收到的参数： " << s << std::endl;

        cout << "CongestionMark: " << interest.getTag<lp::CongestionMarkTag>()->get() << endl;
        assert(interest.getTag<lp::CongestionMarkTag>()->get() == 1);
        cout << "PktType: " << interest.getTag<lp::PktTypeTag>()->get() << endl;
        assert(interest.getTag<lp::PktTypeTag>()->get() == 2);
        cout << "SrcAddr: " << interest.getTag<lp::SrcAddrTag>()->get().getMyPrefix()->toUri() << endl;
        assert(interest.getTag<lp::SrcAddrTag>()->get().getMyPrefix()->toUri() == "/testSrcAddr");
        cout << "DstAddr: " << interest.getTag<lp::DstAddrTag>()->get().getMyPrefix()->toUri() << endl;
        assert(interest.getTag<lp::DstAddrTag>()->get().getMyPrefix()->toUri() == "/testDstAddr");
        cout << "BackupName: " << interest.getTag<lp::BackupNameTag>()->get().getMyPrefix()->toUri() << endl;
        assert(interest.getTag<lp::BackupNameTag>()->get().getMyPrefix()->toUri() == "/testBackupName");
        cout << "CachePolicy: " << interest.getTag<lp::CachePolicyTag>()->get().getPolicy() << endl;
        assert(interest.getTag<lp::CachePolicyTag>()->get().getPolicy() == lp::CachePolicyType::NO_CACHE);

        static const std::string content("Hello, world!");

        // Create Data packet
        auto data = make_shared<Data>(interest.getName());
        data->setFreshnessPeriod(10_s);
        data->setContent(reinterpret_cast<const uint8_t *>(content.data()), content.size());
        data->setTag(make_shared<lp::CongestionMarkTag>(1));
        data->setTag(make_shared<lp::PktTypeTag>(2));
        data->setTag(make_shared<lp::SrcAddrTag>(lp::SrcAddrHeader(Name("/testSrcAddr"))));
        data->setTag(make_shared<lp::DstAddrTag>(lp::DstAddrHeader(Name("/testDstAddr"))));
        data->setTag(make_shared<lp::BackupNameTag>(lp::BackupNameHeader(Name("/testBackupName"))));
        auto cachePolicy = lp::CachePolicy();
        cachePolicy.setPolicy(lp::CachePolicyType::NO_CACHE);
        data->setTag(make_shared<lp::CachePolicyTag>(cachePolicy));

        // Sign Data packet with default identity
        m_keyChain.sign(*data);
        // m_keyChain.sign(*data, signingByIdentity(<identityName>));
        // m_keyChain.sign(*data, signingByKey(<keyName>));
        // m_keyChain.sign(*data, signingByCertificate(<certName>));
        // m_keyChain.sign(*data, signingWithSha256());

        // Return Data packet to the requester
        std::cout << "<< D: " << *data << std::endl;
        m_face.put(*data);
      }

      void
      onRegisterFailed(const Name &prefix, const std::string &reason) {
        std::cerr << "ERROR: Failed to register prefix '" << prefix
                  << "' with the local forwarder (" << reason << ")" << std::endl;
        m_face.shutdown();
      }

    private:
      Face m_face;
      KeyChain m_keyChain;
    };

  } // namespace examples
} // namespace ndn

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

  try {
    ndn::examples::Producer producer;
    producer.run();
    return 0;
  }
  catch (const std::exception &e) {
    std::cerr << "ERROR: " << e.what() << std::endl;
    return 1;
  }
}