"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
const common_1 = require("@nestjs/common");
const speech_config_service_1 = require("./speech-config.service");
let SpeechService = class SpeechService {
    constructor(config) {
        this.config = config;
        this.speechSDK = require('microsoft-cognitiveservices-speech-sdk');
        this.clients = {};
    }
    recognizeOnAsync(buffer) {
        const audioStream = this.speechSDK.AudioInputStream.createPushStream();
        const highWaterMark = 8192 * 8;
        for (let i = 0; i < buffer.length; i += highWaterMark) {
            const chunkSize = i + highWaterMark > buffer.length ? buffer.length : i + highWaterMark;
            const chunk = buffer.slice(i, chunkSize);
            audioStream.write(chunk.slice());
        }
        audioStream.close();
        const recognizer = this.createRecognizer(audioStream);
        const promise = new Promise((resolve, reject) => {
            recognizer.recognizeOnceAsync((result) => {
                resolve(result.json);
                recognizer.close();
            }, (error) => {
                reject(error);
                recognizer.close();
            });
        });
        return promise;
    }
    startContinuousRecognition(clientId, recognizing, recognized) {
        const stream = this.speechSDK.AudioInputStream.createPushStream();
        const recognizer = this.createRecognizer(stream);
        recognizer.canceled = (s, e) => console.log('canceled', s, e);
        recognizer.recognizing = (s, e) => recognizing(e.result.json);
        recognizer.recognized = (s, e) => recognized(e.result.json);
        const promise = new Promise((resolve, reject) => {
            recognizer.recognizeOnceAsync((result) => {
                resolve(result.json);
                recognizer.close();
                delete this.clients[clientId];
            }, (error) => {
                reject(error);
            });
        });
        this.clients[clientId] = { recognizer, stream };
        return promise;
    }
    stopContinousRecognition(clientId) {
        const client = this.clients[clientId];
        if (client) {
            client.stream.close();
        }
    }
    recognizeOnContinous(clientId, buffer) {
        const client = this.clients[clientId];
        if (!client)
            return false;
        client.stream.write(buffer.slice());
    }
    createRecognizer(audioStream, language) {
        const audioConfig = this.speechSDK.AudioConfig.fromStreamInput(audioStream);
        const speechConfig = this.speechSDK.SpeechConfig.fromSubscription(this.config.getSubscriptionKey(), this.config.getRegion());
        speechConfig.endpointId = this.config.getEndpointId();
        speechConfig.speechRecognitionLanguage = language ? language : this.config.getDefaultLanguage();
        const proxy = this.config.getProxy();
        if (proxy) {
            speechConfig.setProxy(proxy.url, proxy.port);
        }
        return new this.speechSDK.SpeechRecognizer(speechConfig, audioConfig);
    }
};
SpeechService = __decorate([
    common_1.Injectable(),
    __metadata("design:paramtypes", [speech_config_service_1.SpeechConfigService])
], SpeechService);
exports.SpeechService = SpeechService;