#include <iostream>
#include <string>
#include <list>
#include <stdint.h>
#include <rdkafkacpp.h>

static bool run = true;
static bool exit_eof = false;

void dump_config(RdKafka::Conf* conf) {
    std::list<std::string> *dump = conf->dump();

    printf("config dump(%d):\n", (int32_t)dump->size());
    for (auto it = dump->begin(); it != dump->end(); ) {
        std::string name = *it++;
        std::string value = *it++;
        printf("%s = %s\n", name.c_str(), value.c_str());
    }

    printf("---------------------------------------------\n");
}

class my_event_cb : public RdKafka::EventCb {
public:
    void event_cb(RdKafka::Event &event) override {
        switch (event.type())
        {
        case RdKafka::Event::EVENT_ERROR:
            std::cerr << "ERROR (" << RdKafka::err2str(event.err()) << "): " <<
                event.str() << std::endl;
            if (event.err() == RdKafka::ERR__ALL_BROKERS_DOWN)
                run = false;
            break;

        case RdKafka::Event::EVENT_STATS:
            std::cerr << "\"STATS\": " << event.str() << std::endl;
            break;

        case RdKafka::Event::EVENT_LOG:
            fprintf(stderr, "LOG-%i-%s: %s\n",
                event.severity(), event.fac().c_str(), event.str().c_str());
            break;

        default:
            std::cerr << "EVENT " << event.type() <<
                " (" << RdKafka::err2str(event.err()) << "): " <<
                event.str() << std::endl;
            break;
        }
    }
};

class my_hash_partitioner_cb : public RdKafka::PartitionerCb {
public:
    int32_t partitioner_cb(const RdKafka::Topic *topic, const std::string *key,
        int32_t partition_cnt, void *msg_opaque) override {
        return djb_hash(key->c_str(), key->size()) % partition_cnt;
    }
private:
    static inline unsigned int djb_hash(const char *str, size_t len) {
        unsigned int hash = 5381;
        for (size_t i = 0; i < len; i++)
            hash = ((hash << 5) + hash) + str[i];
        return hash;
    }
};

namespace producer_ts {

class my_delivery_report_cb : public RdKafka::DeliveryReportCb {
public:
    void dr_cb(RdKafka::Message& message) override {
        printf("message delivery %d bytes, error:%s, key: %s\n",
            (int32_t)message.len(), message.errstr().c_str(), message.key() ? message.key()->c_str() : "");
    }
};

void producer_test() {
    printf("producer test\n");

    int32_t partition = RdKafka::Topic::PARTITION_UA;

    printf("input brokers list(127.0.0.1:9092;127.0.0.1:9093;127.0.0.1:9094):\n");
    std::string broker_list;

    //std::cin >> broker_list;
    broker_list = "127.0.0.1:9092";

    printf("input partition:");

    //std::cin >> partition;
    partition = 0;

    // config 
    RdKafka::Conf* global_conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
    RdKafka::Conf* topic_conf = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC);

    my_hash_partitioner_cb          hash_partitioner;
    my_event_cb                     event_cb;
    my_delivery_report_cb           delivery_cb;
  

    std::string err_string;
    if (topic_conf->set("partitioner_cb", &hash_partitioner, err_string) != RdKafka::Conf::CONF_OK) {
        printf("set partitioner_cb error: %s\n", err_string.c_str());
        return;
    }

    global_conf->set("metadata.broker.list", broker_list, err_string);
    global_conf->set("event_cb", &event_cb, err_string);
    global_conf->set("dr_cb", &delivery_cb, err_string);
    global_conf->set("debug", "all", err_string);

    //dump_config(global_conf);
    //dump_config(topic_conf);


    // create producer
    RdKafka::Producer* producer = RdKafka::Producer::create(global_conf, err_string);
    if (!producer) {
        printf("failed to create producer, %s\n", err_string.c_str());
        return;
    }

    printf("created producer %s\n", producer->name().c_str());

    std::string topic_name;
    while (true) {

        printf("input topic to create:\n");
        std::cin >> topic_name;

        // create topic
        RdKafka::Topic* topic =
            RdKafka::Topic::create(producer, topic_name, topic_conf, err_string);

        if (!topic) {
            printf("try create topic[%s] failed, %s\n",
                topic_name.c_str(), err_string.c_str());
            return;
        }

        printf(">");
        for (std::string line; run && std::getline(std::cin, line); ) {
            if (line.empty()) {
                producer->poll(0);
                continue;
            }

            if (line == "quit") {
                break;
            }

            RdKafka::ErrorCode res = producer->produce(topic, partition,
                RdKafka::Producer::RK_MSG_COPY,
                (char*)line.c_str(), line.size(), NULL, NULL);

            if (res != RdKafka::ERR_NO_ERROR) {
                printf("produce failed, %s\n", RdKafka::err2str(res).c_str());
            }
            else {
                printf("produced msg, bytes %d\n", (int32_t)line.size());
            }

            // do socket io
            producer->poll(0);

            printf("outq_len: %d\n", producer->outq_len());

            //producer->flush(1000);

            //while (run && producer->outq_len()) {
            //    printf("wait for write queue( size %d) write finish\n", producer->outq_len());
            //    producer->poll(1000);
            //}

            printf(">");
        }

        delete topic;

        if (!run) {
            break;
        }
    }

    run = true;

    while (run && producer->outq_len()) {
        printf("wait for write queue( size %d) write finish\n", producer->outq_len());
        producer->poll(1000);
    }

    delete producer;
}
}

>1
produced msg, bytes 1
outq_len: 1
>2
produced msg, bytes 1
outq_len: 2
>3
produced msg, bytes 1
outq_len: 3

LOG-7-TOPPAR: [thrd:HSH-D-3146.wowshga.internal:9092/0]: xxx:9092/0: kafka_cpp_test [0] 3 message(s) in xmit queue (0 added from partition queue)
LOG-7-TOPPAR: [thrd:HSH-D-3146.wowshga.internal:9092/0]: xxx:9092/0: kafka_cpp_test [0] 3 message(s) in xmit queue (0 added from partition queue)
LOG-7-TOPPAR: [thrd:HSH-D-3146.wowshga.internal:9092/0]: xxx:9092/0: kafka_cpp_test [0] 3 message(s) in xmit queue (0 added from partition queue)