package kafka

import (
	"git.hlsq.asia/mmorpg/service-common/config"
	"github.com/IBM/sarama"
	"time"
)

var client *Client

type Client struct {
	producer   sarama.AsyncProducer
	consumer   sarama.ConsumerGroup
	serverName string
}

func Init(cfg *config.KafkaConfig, serverName string) error {
	producer, err := getAsyncProducer(cfg)
	if err != nil {
		return err
	}
	consumer, err := getConsumer(cfg)
	if err != nil {
		return err
	}
	client = &Client{
		producer:   producer,
		consumer:   consumer,
		serverName: serverName,
	}
	go producerError()
	go consumerError()
	return nil
}

func getAsyncProducer(cfg *config.KafkaConfig) (sarama.AsyncProducer, error) {
	conf := sarama.NewConfig()
	conf.Producer.RequiredAcks = sarama.WaitForAll
	conf.Producer.Return.Errors = true
	conf.Producer.Retry.Max = 5
	conf.Producer.Retry.Backoff = 100 * time.Millisecond
	return sarama.NewAsyncProducer(cfg.Brokers, conf)
}

func getConsumer(cfg *config.KafkaConfig) (sarama.ConsumerGroup, error) {
	conf := sarama.NewConfig()
	conf.Consumer.Return.Errors = true
	conf.Consumer.Group.Session.Timeout = 10 * time.Second
	conf.Consumer.Offsets.AutoCommit.Enable = false
	conf.Consumer.Offsets.Initial = sarama.OffsetOldest
	return sarama.NewConsumerGroup(cfg.Brokers, cfg.GroupID, conf)
}

func Close() error {
	if client != nil && client.producer != nil {
		_ = client.producer.Close()
	}
	if client != nil && client.consumer != nil {
		_ = client.consumer.Close()
	}
	return nil
}