"use strict";
/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0.
 */
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __exportStar = (this && this.__exportStar) || function(m, exports) {
    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Mqtt5Client = exports.ClientExtendedValidationAndFlowControl = exports.ClientOperationQueueBehavior = exports.HttpProxyOptions = void 0;
/**
 * Node.js specific MQTT5 client implementation
 *
 * @packageDocumentation
 * @module mqtt5
 * @mergeTarget
 *
 */
const binding_1 = __importDefault(require("./binding"));
const native_resource_1 = require("./native_resource");
const event_1 = require("../common/event");
const io = __importStar(require("./io"));
const mqtt_shared = __importStar(require("../common/mqtt_shared"));
const error_1 = require("./error");
var http_1 = require("./http");
Object.defineProperty(exports, "HttpProxyOptions", { enumerable: true, get: function () { return http_1.HttpProxyOptions; } });
__exportStar(require("../common/mqtt5"), exports);
__exportStar(require("../common/mqtt5_packet"), exports);
;
/**
 * Controls how disconnects affect the queued and in-progress operations tracked by the client.  Also controls
 * how operations are handled while the client is not connected.  In particular, if the client is not connected,
 * then any operation that would be failed on disconnect (according to these rules) will be rejected.
 */
var ClientOperationQueueBehavior;
(function (ClientOperationQueueBehavior) {
    /** Same as FailQos0PublishOnDisconnect */
    ClientOperationQueueBehavior[ClientOperationQueueBehavior["Default"] = 0] = "Default";
    /**
     * Re-queues QoS 1+ publishes on disconnect; un-acked publishes go to the front while unprocessed publishes stay
     * in place.  All other operations (QoS 0 publishes, subscribe, unsubscribe) are failed.
     */
    ClientOperationQueueBehavior[ClientOperationQueueBehavior["FailNonQos1PublishOnDisconnect"] = 1] = "FailNonQos1PublishOnDisconnect";
    /**
     * QoS 0 publishes that are not complete at the time of disconnection are failed.  Un-acked QoS 1+ publishes are
     * re-queued at the head of the line for immediate retransmission on a session resumption.  All other operations
     * are requeued in original order behind any retransmissions.
     */
    ClientOperationQueueBehavior[ClientOperationQueueBehavior["FailQos0PublishOnDisconnect"] = 2] = "FailQos0PublishOnDisconnect";
    /**
     * All operations that are not complete at the time of disconnection are failed, except operations that
     * the MQTT5 spec requires to be retransmitted (un-acked QoS1+ publishes).
     */
    ClientOperationQueueBehavior[ClientOperationQueueBehavior["FailAllOnDisconnect"] = 3] = "FailAllOnDisconnect";
})(ClientOperationQueueBehavior = exports.ClientOperationQueueBehavior || (exports.ClientOperationQueueBehavior = {}));
/**
 * Additional controls for client behavior with respect to operation validation and flow control; these checks
 * go beyond the MQTT5 spec to respect limits of specific MQTT brokers.
 */
var ClientExtendedValidationAndFlowControl;
(function (ClientExtendedValidationAndFlowControl) {
    /**
     * Do not do any additional validation or flow control
     */
    ClientExtendedValidationAndFlowControl[ClientExtendedValidationAndFlowControl["None"] = 0] = "None";
    /**
     * Apply additional client-side validation and operational flow control that respects the
     * default AWS IoT Core limits.
     *
     * Currently applies the following additional validation:
     *
     * 1. No more than 8 subscriptions per SUBSCRIBE packet
     * 1. Topics and topic filters have a maximum of 7 slashes (8 segments), not counting any AWS rules prefix
     * 1. Topics must be <= 256 bytes in length
     * 1. Client id must be <= 128 bytes in length
     *
     * Also applies the following flow control:
     *
     * 1. Outbound throughput throttled to 512KB/s
     * 1. Outbound publish TPS throttled to 100
     */
    ClientExtendedValidationAndFlowControl[ClientExtendedValidationAndFlowControl["AwsIotCoreDefaults"] = 1] = "AwsIotCoreDefaults";
})(ClientExtendedValidationAndFlowControl = exports.ClientExtendedValidationAndFlowControl || (exports.ClientExtendedValidationAndFlowControl = {}));
/**
 * Node.js specific MQTT5 client implementation
 *
 * Not all parts of the MQTT5 spec are supported. We currently do not support:
 *
 * * AUTH packets and the authentication fields in the CONNECT packet
 * * QoS 2
 *
 * This client is based on native resources.  When finished with the client, you must call close() to dispose of
 * them or they will leak.
 *
 */
class Mqtt5Client extends (0, native_resource_1.NativeResourceMixin)(event_1.BufferedEventEmitter) {
    /**
     * Client constructor
     *
     * @param config The configuration for this client
     */
    constructor(config) {
        super();
        this._super(binding_1.default.mqtt5_client_new(this, config, (client) => { Mqtt5Client._s_on_stopped(client); }, (client) => { Mqtt5Client._s_on_attempting_connect(client); }, (client, connack, settings) => { Mqtt5Client._s_on_connection_success(client, connack, settings); }, (client, errorCode, connack) => { Mqtt5Client._s_on_connection_failure(client, new error_1.CrtError(errorCode), connack); }, (client, errorCode, disconnect) => { Mqtt5Client._s_on_disconnection(client, new error_1.CrtError(errorCode), disconnect); }, (client, message, pubackControlId) => { Mqtt5Client._s_on_message_received(client, message, pubackControlId); }, config.clientBootstrap ? config.clientBootstrap.native_handle() : null, config.socketOptions ? config.socketOptions.native_handle() : null, config.tlsCtx ? config.tlsCtx.native_handle() : null, config.httpProxyOptions ? config.httpProxyOptions.create_native_handle() : null, config.disableMetrics == true ? undefined : new mqtt_shared.AwsIoTDeviceSDKMetrics()));
    }
    /**
     * Triggers cleanup of native resources associated with the MQTT5 client.  Once this has been invoked, callbacks
     * and events are not guaranteed to be received.
     *
     * This must be called when finished with a client; otherwise, native resources will leak.  It is not safe
     * to invoke any further operations on the client after close() has been called.
     *
     * For a running client, safe and proper shutdown can be accomplished by
     *
     * ```ts
     * const stopped = once(client, "stopped");
     * client.stop();
     * await stopped;
     * client.close();
     * ```
     *
     * This is an asynchronous operation.
     *
     * @group Node-only
     */
    close() {
        binding_1.default.mqtt5_client_close(this.native_handle());
    }
    /**
     * Notifies the MQTT5 client that you want it to maintain connectivity to the configured endpoint.
     * The client will attempt to stay connected using the properties of the reconnect-related parameters
     * in the mqtt5 client configuration.
     *
     * This is an asynchronous operation.
     */
    start() {
        binding_1.default.mqtt5_client_start(this.native_handle());
    }
    /**
     * Notifies the MQTT5 client that you want it to end connectivity to the configured endpoint, disconnecting any
     * existing connection and halting reconnection attempts.
     *
     * This is an asynchronous operation.  Once the process completes, no further events will be emitted until the client
     * has {@link start} invoked.  Invoking {@link start start()} after a {@link stop stop()} will always result in a
     * new MQTT session.
     *
     * @param disconnectPacket (optional) properties of a DISCONNECT packet to send as part of the shutdown process
     */
    stop(disconnectPacket) {
        binding_1.default.mqtt5_client_stop(this.native_handle(), disconnectPacket);
    }
    /**
     * Subscribe to one or more topic filters by queuing a SUBSCRIBE packet to be sent to the server.
     *
     * @param packet SUBSCRIBE packet to send to the server
     * @returns a promise that will be rejected with an error or resolved with the SUBACK response
     */
    subscribe(packet) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                function curriedPromiseCallback(client, errorCode, suback) {
                    return Mqtt5Client._s_on_suback_callback(resolve, reject, client, errorCode, suback);
                }
                try {
                    binding_1.default.mqtt5_client_subscribe(this.native_handle(), packet, curriedPromiseCallback);
                }
                catch (e) {
                    reject(e);
                }
            });
        });
    }
    /**
     * Unsubscribe from one or more topic filters by queuing an UNSUBSCRIBE packet to be sent to the server.
     *
     * @param packet UNSUBSCRIBE packet to send to the server
     * @returns a promise that will be rejected with an error or resolved with the UNSUBACK response
     */
    unsubscribe(packet) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                function curriedPromiseCallback(client, errorCode, unsuback) {
                    return Mqtt5Client._s_on_unsuback_callback(resolve, reject, client, errorCode, unsuback);
                }
                try {
                    binding_1.default.mqtt5_client_unsubscribe(this.native_handle(), packet, curriedPromiseCallback);
                }
                catch (e) {
                    reject(e);
                }
            });
        });
    }
    /**
     * Send a message to subscribing clients by queuing a PUBLISH packet to be sent to the server.
     *
     * @param packet PUBLISH packet to send to the server
     * @returns a promise that will be rejected with an error or resolved with the PUBACK response (QoS 1) or
     * undefined (QoS 0)
     */
    publish(packet) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                if (packet && packet.payload) {
                    packet.payload = mqtt_shared.normalize_payload(packet.payload);
                }
                function curriedPromiseCallback(client, errorCode, result) {
                    return Mqtt5Client._s_on_puback_callback(resolve, reject, client, errorCode, result);
                }
                try {
                    binding_1.default.mqtt5_client_publish(this.native_handle(), packet, curriedPromiseCallback);
                }
                catch (e) {
                    reject(e);
                }
            });
        });
    }
    /**
     * Queries a small set of numerical statistics about the current state of the client's operation queue
     *
     * @group Node-only
     */
    getOperationalStatistics() {
        return binding_1.default.mqtt5_client_get_queue_statistics(this.native_handle());
    }
    /**
     * Queries a small set of numerical statistics about the current state of the client's operation queue
     * @deprecated use getOperationalStatistics instead
     *
     * @group Node-only
     */
    getQueueStatistics() {
        return this.getOperationalStatistics();
    }
    on(event, listener) {
        super.on(event, listener);
        return this;
    }
    /*
     * Private helper functions
     *
     * Callbacks come through static functions so that the native threadsafe function objects do not
     * capture the client object itself, simplifying the number of strong references to the client floating around.
     */
    static _s_on_stopped(client) {
        process.nextTick(() => {
            let stoppedEvent = {};
            client.emit(Mqtt5Client.STOPPED, stoppedEvent);
        });
    }
    static _s_on_attempting_connect(client) {
        process.nextTick(() => {
            let attemptingConnectEvent = {};
            client.emit(Mqtt5Client.ATTEMPTING_CONNECT, attemptingConnectEvent);
        });
    }
    static _s_on_connection_success(client, connack, settings) {
        let connectionSuccessEvent = {
            connack: connack,
            settings: settings
        };
        process.nextTick(() => {
            client.emit(Mqtt5Client.CONNECTION_SUCCESS, connectionSuccessEvent);
        });
    }
    static _s_on_connection_failure(client, error, connack) {
        let connectionFailureEvent = {
            error: error
        };
        if (connack !== null && connack !== undefined) {
            connectionFailureEvent.connack = connack;
        }
        process.nextTick(() => {
            client.emit(Mqtt5Client.CONNECTION_FAILURE, connectionFailureEvent);
        });
    }
    static _s_on_disconnection(client, error, disconnect) {
        let disconnectionEvent = {
            error: error
        };
        if (disconnect !== null && disconnect !== undefined) {
            disconnectionEvent.disconnect = disconnect;
        }
        process.nextTick(() => {
            client.emit(Mqtt5Client.DISCONNECTION, disconnectionEvent);
        });
    }
    static _s_on_suback_callback(resolve, reject, client, errorCode, suback) {
        if (errorCode == 0 && suback !== undefined) {
            resolve(suback);
        }
        else {
            reject(io.error_code_to_string(errorCode));
        }
    }
    static _s_on_unsuback_callback(resolve, reject, client, errorCode, unsuback) {
        if (errorCode == 0 && unsuback !== undefined) {
            resolve(unsuback);
        }
        else {
            reject(io.error_code_to_string(errorCode));
        }
    }
    static _s_on_puback_callback(resolve, reject, client, errorCode, result) {
        if (errorCode == 0) {
            resolve(result);
        }
        else {
            reject(io.error_code_to_string(errorCode));
        }
    }
    static _s_on_message_received(client, message, pubackControlId) {
        let acknowledgementControl = undefined;
        if (pubackControlId !== undefined) {
            const controlId = pubackControlId;
            acknowledgementControl = new mqtt_shared.PublishAcknowledgementHandleWrapper(new mqtt_shared.PublishAcknowledgementHandle(() => {
                binding_1.default.mqtt5_client_invoke_publish_acknowledgement(client.native_handle(), controlId);
            }));
        }
        let messageReceivedEvent = {
            message: message
        };
        if (acknowledgementControl) {
            messageReceivedEvent.acknowledgementControl = acknowledgementControl;
        }
        process.nextTick(() => {
            client.emitWithCallback(Mqtt5Client.MESSAGE_RECEIVED, () => {
                /*
                 * Even if corked, all listeners have had a chance to react to the event
                 * and acquire the acknowledgement handle if they wanted to.  If no one did so, then we do it ourselves.
                 */
                if (acknowledgementControl) {
                    const handle = acknowledgementControl.acquireHandle();
                    if (handle) {
                        handle.invokeAcknowledgement();
                    }
                }
            }, messageReceivedEvent);
        });
    }
}
exports.Mqtt5Client = Mqtt5Client;
/**
 * Event emitted when the client encounters a serious error condition, such as invalid input, napi failures, and
 * other potentially unrecoverable situations.
 *
 * Listener type: {@link ErrorEventListener}
 *
 * @event
 */
Mqtt5Client.ERROR = 'error';
/**
 * Event emitted when an MQTT PUBLISH packet is received by the client.
 *
 * Listener type: {@link MessageReceivedEventListener}
 *
 * @event
 */
Mqtt5Client.MESSAGE_RECEIVED = 'messageReceived';
/**
 * Event emitted when the client begins a connection attempt.
 *
 * Listener type: {@link AttemptingConnectEventListener}
 *
 * @event
 */
Mqtt5Client.ATTEMPTING_CONNECT = 'attemptingConnect';
/**
 * Event emitted when the client successfully establishes an MQTT connection.  Only emitted after
 * an {@link ATTEMPTING_CONNECT attemptingConnect} event.
 *
 * Listener type: {@link ConnectionSuccessEventListener}
 *
 * @event
 */
Mqtt5Client.CONNECTION_SUCCESS = 'connectionSuccess';
/**
 * Event emitted when the client fails to establish an MQTT connection.  Only emitted after
 * an {@link ATTEMPTING_CONNECT attemptingConnect} event.
 *
 * Listener type: {@link ConnectionFailureEventListener}
 *
 * @event
 */
Mqtt5Client.CONNECTION_FAILURE = 'connectionFailure';
/**
 * Event emitted when the client's current connection is closed for any reason.  Only emitted after
 * a {@link CONNECTION_SUCCESS connectionSuccess} event.
 *
 * Listener type: {@link DisconnectionEventListener}
 *
 * @event
 */
Mqtt5Client.DISCONNECTION = 'disconnection';
/**
 * Event emitted when the client finishes shutdown as a result of the user invoking {@link stop}.
 *
 * Listener type: {@link StoppedEventListener}
 *
 * @event
 */
Mqtt5Client.STOPPED = 'stopped';
//# sourceMappingURL=mqtt5.js.map