from producer import Updater
app = Celery('kafka-producer', broker=os.environ["CELERY_BROKER"], backend=os.environ["CELERY_RESULTS"])

@app.task
def send_update(key: str, value: str, queue: str):
    kafka_con = Updater()
    response = kafka_con.push_to_kafka(key, value, queue)

from confluent_kafka import Producer, KafkaException


class Updater:
    def __init__(self):
        self.logger = build_logger("producer")
        self.producer = Producer(self.get_config())
        self.poll_delay = float(os.environ.get("KAFKA_POLL_INTERVAL", 0))

    def get_config(self) -> dict:
        base = {'bootstrap.servers': os.environ["KAFKA_BROKER"], "security.protocol": "sasl_plaintext",
                "sasl.mechanism": "PLAIN", "client.id": "client_id", "enable.idempotence": True,
                "queue.buffering.max.messages": 1,  ## Desperate attempt #1
                "sasl.username": os.environ.get("KAFKA_USER", "client_id"),
                "sasl.password": os.environ["KAFKA_PASSWORD"]}
        return base

    def delivery_report(self, err, msg):
        if err:
            raise Exception("Delivery failed for User record {}: {}".format(msg.key(), err))
        else:
            self.logger.debug(
                f'Log key {msg.key()} successfully produced to {msg.topic()} [{msg.partition()}] at offset {msg.offset()}')

    def push_to_kafka(self, key: str, value: str, queue_name: str):
        try:
            self.producer.produce(queue_name, key=key, value=value, callback=self.delivery_report)
            self.producer.poll(self.poll_delay) ## Desperate attempt #2
        except KafkaException as ke:
            self.logger.warning(f"Encountered Kafka error for key {key}, {ke}.")
            raise
        except Exception as e:
            self.logger.warning(f"Generic error for key {key}, {e}.")
        else:
            self.producer.flush(self.poll_delay)
            self.logger.debug(f"Key {key} successfully pushed to topic Kafka topic {queue_name}: {value}")