import * as tls from "tls";
import * as Kafka from "./kafka";
import { Client } from "./client";

export class Producer {
    constructor(options?: ProducerOptions);
    /**
      * Initializes the client for the producer.
      * 
      * @returns {Promise<Client>} 
      * 
      * @memberOf Producer
      */
    init(): Promise<Client>;
    /**
      * The send can take a single message or an array of messages.
      * It can have options
      * @memberOf Producer
      */
    send(data: Kafka.Message | Kafka.Message[], options?: SendOptions): Promise<Result[]>;
    /**
      * Close all connections.
      */
    end(): Promise<void>;
}

export interface ProducerOptions {
    /**
      * requiredAcks - require acknoledgments for produce request. 
      * If it is 0 the server will not send any response. 
      * If it is 1 (default), the server will wait the data 
      * is written to the local log before sending a response.
      * If it is -1 the server will block until the message is
      * committed by all in sync replicas before sending a response.
      * For any number > 1 the server will block waiting
      * for this number of acknowledgements to occur
      * (but the server will never wait for more acknowledgements
      * than there are in-sync replicas).
      * 
      * default: 1
      */
    requiredAcks?: number;
    /**
      * timeout - timeout in ms for produce request
      */
    timeout?: number;
    /**
      * clientId - ID of this client.
      * 
      * defaults to "no-kafka-client"
      */
    clientId?: string;
    /**
      * connectionString - comma delimited list of initial brokers list.
      * 
      * default: "127.0.0.1:9092"
      */
    connectionString?: string;
    /**
      * reconnectionDelay - controls optionally progressive 
      * delay between reconnection attempts in case of network error:
      */
    reconnectionDelay?: {
        /**
          * min - minimum delay, used as increment value for next attempts.
          * 
          * defaults to 1000ms
          */
        min?: number;
        /**
          * max - maximum delay value.
          * 
          * defaults to 1000ms
          */
        max?: number;
    }
    /**
      * partitioner - Class instance used to determine topic partition for message.
      * If message already specifies a partition,
      * the partitioner won't be used.
      * The partitioner must inherit from Kafka.DefaultPartitioner.
      */
    partitioner?: Kafka.DefaultPartitioner;
    /**
      * retries - controls number of attempts at delay 
      * between them when produce request fails
      */
    retries?: number;
    /**
      * attempts - number of total attempts to send the message.
      * 
      * defaults to 3
      */
    attempts?: number;
    /**
      * delay - controls delay between retries, 
      * the delay is progressive and incrememented 
      * with each attempt with min value steps up 
      * to but not exceeding max value
      */
    delay?: {
        /**
          * min - minimum delay, used as increment value for next attempts.
          * 
          * defaults to 1000ms
          */
        min?: number;
        /**
          * max - maximum delay value.
          * 
          * defaults to 3000ms
          */
        max?: number;
    }

    /**
      * codec - compression codec.
      */
    codec?: Kafka.COMPRESSION;
    /**
      * batch - control batching (grouping) of requests
      */
    batch?: {
        /**
          * size - group messages together into single batch 
          * until their total size exceeds this value.
          * Set to 0 to disable batching.
          * 
          * defaults to 16384 bytes.
          */
        size?: number;
        /**
          * maxWait - send grouped messages after this
          * amount of milliseconds expire even if their
          * total size doesn't exceed batch.size yet.
          * Set to 0 to disable batching.
          * 
          * defaults to 10ms.
          */
        maxWait?: number;
    }
    /**
      * asyncCompression - boolean, use asynchronouse 
      * compression instead of synchronous.
      * 
      * defaults to false
      */
    asyncCompression?: boolean;

    /**
      * To connect to Kafka with SSL endpoint enabled 
      * specify SSL certificate and key options to 
      * load cert/key from files or provide certificate/key 
      * directly as strings.
      * 
      * Should match `listeners` SSL option in Kafka config
      */
    ssl?: tls.ConnectionOptions;
    /**
      * connectionTimeout - timeout for establishing connection to Kafka in milliseconds
      * 
      * defaults to 3000ms
      */
    connectionTimeout?: number
    /**
      * socketTimeout - timeout for Kafka connection socket in milliseconds
      * 
      * defaults to 0 (disabled)
      */
    socketTimeout?: number

    brokerRedirection?: Kafka.BrokerRedirectionFunction | Kafka.BrokerRedirectionMap;

    logger?: Kafka.Logger;
}


export interface Result {
    topic: string;
    partition: number;
    offset: number;
}

export interface SendOptions {
    /**
      * requiredAcks - require acknoledgments for produce request. 
      * If it is 0 the server will not send any response. 
      * If it is 1, the server will wait the data is 
      * written to the local log before sending a response. 
      * If it is -1 the server will block until the message 
      * is committed by all in sync replicas before sending a response. 
      * For any number > 1 the server will block waiting for 
      * this number of acknowledgements to occur 
      * (but the server will never wait for more acknowledgements 
      * than there are in-sync replicas).
      * default: 1
      */
    requiredAcks?: number;
    /** 
      * timeout - timeout in ms for produce request
      */
    timeout?: number;
    /**
      * clientId - ID of this client
      * default: 'no-kafka-client'
      */
    clientId?: string;
    /**
      * connectionString - comma delimited list of initial brokers list, 
      * default: '127.0.0.1:9092'
      */
    connectionString?: string;
    /**
      * reconnectionDelay - controls optionally progressive 
      * delay between reconnection attempts in case of network error:
      */
    reconnectionDelay?: {
        /**
          * min - minimum delay, used as increment value for next attempts.
          * default: 1000ms
          */
        min: number;
        /**
          * max - maximum delay value.
          * default: 1000ms
          */
        max: number;
    }
    /**
      * partitioner - Class instance used to determine topic partition for message.
      * If message already specifies a partition, the partitioner won't be used.
      * The partitioner must inherit from Kafka.DefaultPartitioner.
      * The partition method receives 3 arguments: the topic name,
      * an array with topic partitions, and the message (useful to partition by key, etc.).
      * partition can be sync or async (return a Promise).
      */
    partitioner?: any;
    /**
      * retries - controls number of attempts at delay 
      * between them when produce request fails
      */
    retries?: {

        /**
          * attempts - number of total attempts to send the message.
          * default: 3
          */
        attempts?: number;
        /**
          * delay - controls delay between retries,
          * the delay is progressive and incrememented
          * with each attempt with min value steps up to but not exceeding max value
          */
        delay?: {
            /**
              * min - minimum delay, used as increment value for next attempts.
              * default: 1000ms
              */
            min?: number;
            /**
              * max - maximum delay value.
              * default: 3000ms
              */
            max?: number;
        }
    }

    /**
      * codec - compression codec, one of 
      *   Kafka.COMPRESSION_NONE, Kafka.COMPRESSION_SNAPPY, Kafka.COMPRESSION_GZIP
      */
    codec?: number; // Kafka.COMPRESSION_NONE | Kafka.COMPRESSION_SNAPPY | Kafka.COMPRESSION_GZIP;
    /**
      * batch - control batching (grouping) of requests
      */
    batch?: {
        /**
          * size - group messages together into single 
          * batch until their total size exceeds this value.
          * default: 16384 bytes.
          * Set to 0 to disable batching.
          */
        size?: number;
        /**
          * maxWait - send grouped messages after this amount of 
          * milliseconds expire even if their total size 
          * doesn't exceed batch.size yet.
          * default: 10ms.
          * Set to 0 to disable batching.
          */
        maxWait?: number;
        /**
          * asyncCompression - boolean, 
          * use asynchronouse compression instead of synchronous.
          * default: false
          */
        asyncCompression?: boolean;
    }
}