azurespeechservice.cpp

#include "azurespeechservice.h"

#include <QDateTime>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QNetworkProxy>
#include <QNetworkRequest>
#include <QRegularExpression>
#include <QUrl>
#include <QUrlQuery>
#include <QUuid>
#include <QtGlobal>

#include <cstring>

namespace {
QStringList splitList(const QString &value) {
    QStringList result;
    const QStringList parts = value.split(QRegularExpression("[,;]"),
                                          Qt::SkipEmptyParts);
    for (const auto &raw : parts) {
        const QString item = raw.trimmed();
        if (!item.isEmpty())
            result.append(item);
    }
    return result;
}
} // namespace

AzureSpeechService::AzureSpeechService(QObject *parent)
    : SpeechService(parent) {
    connect(&socket, &QWebSocket::connected, this, &AzureSpeechService::handleConnected);
    connect(&socket, &QWebSocket::disconnected, this, &AzureSpeechService::handleDisconnected);
    connect(&socket, &QWebSocket::textMessageReceived, this, &AzureSpeechService::handleTextMessage);
    connect(&socket, &QWebSocket::errorOccurred, this, &AzureSpeechService::handleSocketError);
}

QString AzureSpeechService::providerId() const {
    return QStringLiteral("azure");
}

void AzureSpeechService::start(const AppConfig &config, const AudioSpec &spec) {
    start(config, spec, 0);
}

void AzureSpeechService::start(const AppConfig &config, const AudioSpec &spec, int sessionId) {
    serviceSessionId = sessionId;
    
    resetState();
    stopRequested = false;
    currentSettings = config.azure;
    currentSpec = spec;

    if (currentSettings.apiKey.trimmed().isEmpty()) {
        emit errorOccurred(tr("Azure API key is missing."));
        return;
    }

    if (currentSpec.sampleRate <= 0 || currentSpec.channels <= 0 || currentSpec.format.isEmpty()) {
        emit errorOccurred(tr("Invalid audio format settings."));
        return;
    }

    QString headerError;
    bool littleEndian = true;
    SampleType sampleType = SampleType::Signed;
    int bitsPerSample = 0;
    if (!parsePcmFormat(currentSpec.format, &bitsPerSample, &littleEndian, &sampleType, &headerError)) {
        emit errorOccurred(headerError.isEmpty()
                               ? tr("Unsupported audio format for Azure.")
                               : headerError);
        return;
    }
    if (!littleEndian) {
        emit errorOccurred(tr("Only little-endian PCM is supported."));
        return;
    }

    inputBitsPerSample = bitsPerSample;
    inputSampleType = sampleType;
    needsConversion = !(sampleType == SampleType::Signed && bitsPerSample == 16);

    const int wavBitsPerSample = needsConversion ? 16 : bitsPerSample;
    if (!buildWavHeader(currentSpec, wavBitsPerSample, &wavHeader, &headerError)) {
        emit errorOccurred(headerError.isEmpty()
                               ? tr("Unsupported audio format for Azure.")
                               : headerError);
        return;
    }

    sessionActive = true;

    // Generate new requestId for each session
    requestId = QUuid::createUuid().toString(QUuid::WithoutBraces);
    requestId.remove(QLatin1Char('-'));

    // If already connected, send config and signal ready
    if (socket.state() == QAbstractSocket::ConnectedState) {
        sendAzureConfig();
        emit readyForAudio();
        return;
    }

    // If currently connecting, wait
    if (socket.state() == QAbstractSocket::ConnectingState) {
        return;
    }

    // Open new connection
    if (socket.state() != QAbstractSocket::UnconnectedState) {
        socket.abort();
    }

    if (!applyProxy(currentSettings.proxy))
        return;

    connectionId = QUuid::createUuid().toString(QUuid::WithoutBraces);
    connectionId.remove(QLatin1Char('-'));

    const QUrl url = buildServiceUrl(currentSettings, connectionId);
    if (!url.isValid()) {
        emit errorOccurred(tr("Invalid Azure API endpoint."));
        return;
    }

    QNetworkRequest request(url);
    request.setRawHeader("Ocp-Apim-Subscription-Key", currentSettings.apiKey.toUtf8());
    if (!connectionId.isEmpty())
        request.setRawHeader("X-ConnectionId", connectionId.toUtf8());

    socket.open(request);
}

void AzureSpeechService::stop() {
    stopRequested = true;
    sessionActive = false;
    
    // Send final audio marker to complete this turn
    if (socket.state() == QAbstractSocket::ConnectedState) {
        socket.sendBinaryMessage(buildBinaryMessage(QStringLiteral("audio"),
                                                    requestId,
                                                    QString(),
                                                    QByteArray()));
    }
    // Don't close socket - keep it alive for next session
}

void AzureSpeechService::sendAudio(const QByteArray &data) {
    if (!sessionActive || socket.state() != QAbstractSocket::ConnectedState || data.isEmpty())
        return;

    const QByteArray payload = needsConversion ? convertToPcm16(data) : data;
    if (payload.isEmpty())
        return;

    socket.sendBinaryMessage(buildBinaryMessage(QStringLiteral("audio"),
                                                requestId,
                                                QString(),
                                                payload));
}

bool AzureSpeechService::isActive() const {
    return sessionActive && socket.state() == QAbstractSocket::ConnectedState;
}
void AzureSpeechService::disconnect() {
    sessionActive = false;
    
    if (socket.state() != QAbstractSocket::UnconnectedState) {
        socket.abort();
    }
}
void AzureSpeechService::handleConnected() {
    sendAzureConfig();
    emit readyForAudio();
}

void AzureSpeechService::handleDisconnected() {
    if (sessionActive) {
        sessionActive = false;
        emit errorOccurred(tr("Connection lost."));
    }
}

void AzureSpeechService::handleTextMessage(const QString &message) {
    QString headerBlock;
    QString body;
    int separator = message.indexOf(QStringLiteral("\r\n\r\n"));
    if (separator >= 0) {
        headerBlock = message.left(separator);
        body = message.mid(separator + 4);
    } else {
        separator = message.indexOf(QStringLiteral("\n\n"));
        if (separator >= 0) {
            headerBlock = message.left(separator);
            body = message.mid(separator + 2);
        } else {
            body = message;
        }
    }

    const QMap<QString, QString> headers = parseHeaders(headerBlock);
    const QString path = headers.value(QStringLiteral("path")).toLower();

    if (path == QStringLiteral("turn.end")) {
        // Don't close socket - keep persistent connection
        // Just signal that this dictation session is complete
        if (sessionActive) {
            emit finished(serviceSessionId);
        }
        return;
    }

    if (body.trimmed().isEmpty())
        return;

    QJsonParseError parseError{};
    const QJsonDocument doc = QJsonDocument::fromJson(body.toUtf8(), &parseError);
    if (parseError.error != QJsonParseError::NoError || !doc.isObject())
        return;

    const QJsonObject root = doc.object();

    if (path == QStringLiteral("speech.hypothesis") ||
        path == QStringLiteral("speech.fragment")) {
        const QString text = extractResultText(root);
        if (!text.isEmpty()) {
            currentText = text;
            emitTranscript();
        }
        return;
    }

    if (path == QStringLiteral("speech.phrase")) {
        const QString errorText = extractErrorText(root);
        if (!errorText.isEmpty()) {
            emit errorOccurred(errorText);
            return;
        }

        const QString status = root.value(QStringLiteral("RecognitionStatus")).toString();
        if (!status.isEmpty()) {
            const QString lower = status.toLower();
            if (lower == QStringLiteral("nomatch") ||
                lower == QStringLiteral("initialsilencetimeout") ||
                lower == QStringLiteral("babbletimeout")) {
                return;
            }
            if (lower == QStringLiteral("endofdictation")) {
                return;
            }
        }

        const QString text = extractResultText(root);
        if (!text.isEmpty()) {
            appendCommittedText(text);
            currentText.clear();
            emitTranscript();
        }
    }
}

void AzureSpeechService::handleSocketError(QAbstractSocket::SocketError error) {
    Q_UNUSED(error);
    emit errorOccurred(socket.errorString());
}

void AzureSpeechService::sendAzureConfig() {
    QJsonObject system{
        {"name", QStringLiteral("VoiceToKeys")},
        {"version", QStringLiteral("1.0")},
        {"build", QStringLiteral("Qt")},
        {"lang", QStringLiteral("C++")}
    };
    QJsonObject configRoot{
        {"context", QJsonObject{{"system", system}}},
        {"recognition", QStringLiteral("conversation")}
    };
    const QJsonDocument configDoc(configRoot);
    socket.sendTextMessage(buildTextMessage(QStringLiteral("speech.config"),
                                            requestId,
                                            QStringLiteral("application/json"),
                                            QString::fromUtf8(configDoc.toJson(QJsonDocument::Compact))));

    QJsonObject contextRoot;
    const QStringList phraseHints = splitList(currentSettings.phraseHints);
    if (!phraseHints.isEmpty()) {
        QJsonArray items;
        for (const auto &phrase : phraseHints) {
            items.append(QJsonObject{{"text", phrase}});
        }
        QJsonArray groups;
        groups.append(QJsonObject{
            {"type", QStringLiteral("Generic")},
            {"items", items}
        });
        contextRoot.insert("dgi", QJsonObject{
            {"groups", groups},
            {"bias", 1.0}
        });
    }

    const QStringList languageHints = splitList(currentSettings.languageHints);
    if (currentSettings.languageHintsStrict && !languageHints.isEmpty()) {
        QJsonArray languages;
        for (const auto &lang : languageHints)
            languages.append(lang);
        contextRoot.insert("languageId", QJsonObject{
            {"languages", languages},
            {"mode", QStringLiteral("DetectAtAudioStart")},
            {"onSuccess", QJsonObject{{"action", QStringLiteral("Recognize")}}},
            {"onUnknown", QJsonObject{{"action", QStringLiteral("None")}}},
            {"priority", QStringLiteral("PrioritizeLatency")}
        });
        contextRoot.insert("phraseOutput", QJsonObject{
            {"interimResults", QJsonObject{{"resultType", QStringLiteral("Auto")}}},
            {"phraseResults", QJsonObject{{"resultType", QStringLiteral("Always")}}}
        });
    }

    const QJsonDocument contextDoc(contextRoot);
    socket.sendTextMessage(buildTextMessage(QStringLiteral("speech.context"),
                                            requestId,
                                            QStringLiteral("application/json"),
                                            QString::fromUtf8(contextDoc.toJson(QJsonDocument::Compact))));

    socket.sendBinaryMessage(buildBinaryMessage(QStringLiteral("audio"),
                                                requestId,
                                                QStringLiteral("audio/x-wav"),
                                                wavHeader));
}

void AzureSpeechService::resetState() {
    committedText.clear();
    currentText.clear();
    requestId.clear();
    connectionId.clear();
    wavHeader.clear();
    stopRequested = false;
    needsConversion = false;
    inputBitsPerSample = 0;
    inputSampleType = SampleType::Signed;
}

bool AzureSpeechService::applyProxy(const QString &proxyString) {
    const QString trimmed = proxyString.trimmed();
    if (trimmed.isEmpty()) {
        socket.setProxy(QNetworkProxy::NoProxy);
        return true;
    }

    QUrl url(trimmed);
    if (url.scheme().isEmpty())
        url = QUrl(QStringLiteral("http://") + trimmed);

    QNetworkProxy proxy;
    if (url.scheme().startsWith("socks", Qt::CaseInsensitive))
        proxy.setType(QNetworkProxy::Socks5Proxy);
    else
        proxy.setType(QNetworkProxy::HttpProxy);

    proxy.setHostName(url.host());
    proxy.setPort(static_cast<quint16>(url.port(443)));
    proxy.setUser(url.userName());
    proxy.setPassword(url.password());

    if (proxy.hostName().isEmpty() || proxy.port() == 0) {
        emit errorOccurred(tr("Invalid proxy address."));
        socket.setProxy(QNetworkProxy::NoProxy);
        return false;
    }

    socket.setProxy(proxy);
    return true;
}

bool AzureSpeechService::buildWavHeader(const AudioSpec &spec, int bitsPerSample,
                                        QByteArray *header, QString *error) const {
    if (!header)
        return false;

    if (bitsPerSample <= 0 || bitsPerSample % 8 != 0) {
        if (error)
            *error = tr("Unsupported audio sample size.");
        return false;
    }

    if (spec.sampleRate <= 0 || spec.channels <= 0) {
        if (error)
            *error = tr("Invalid audio format settings.");
        return false;
    }

    const int blockAlign = spec.channels * (bitsPerSample / 8);
    const int byteRate = spec.sampleRate * blockAlign;

    QByteArray wav(44, 0);
    auto write16 = [&wav](int offset, quint16 value) {
        wav[offset] = static_cast<char>(value & 0xff);
        wav[offset + 1] = static_cast<char>((value >> 8) & 0xff);
    };
    auto write32 = [&wav](int offset, quint32 value) {
        wav[offset] = static_cast<char>(value & 0xff);
        wav[offset + 1] = static_cast<char>((value >> 8) & 0xff);
        wav[offset + 2] = static_cast<char>((value >> 16) & 0xff);
        wav[offset + 3] = static_cast<char>((value >> 24) & 0xff);
    };

    memcpy(wav.data() + 0, "RIFF", 4);
    write32(4, 0);
    memcpy(wav.data() + 8, "WAVEfmt ", 8);
    write32(16, 16);
    write16(20, 1);
    write16(22, static_cast<quint16>(spec.channels));
    write32(24, static_cast<quint32>(spec.sampleRate));
    write32(28, static_cast<quint32>(byteRate));
    write16(32, static_cast<quint16>(blockAlign));
    write16(34, static_cast<quint16>(bitsPerSample));
    memcpy(wav.data() + 36, "data", 4);
    write32(40, 0);

    *header = wav;
    return true;
}

bool AzureSpeechService::parsePcmFormat(const QString &format, int *bitsPerSample,
                                        bool *littleEndian, SampleType *sampleType,
                                        QString *error) const {
    if (bitsPerSample)
        *bitsPerSample = 0;
    if (littleEndian)
        *littleEndian = true;
    if (sampleType)
        *sampleType = SampleType::Signed;

    const QString trimmed = format.trimmed();
    if (trimmed.isEmpty()) {
        if (error)
            *error = tr("Unsupported audio format for Azure.");
        return false;
    }

    QRegularExpression regex(QStringLiteral("^pcm_([usf])(\\d+)(le|be)?$"),
                             QRegularExpression::CaseInsensitiveOption);
    const QRegularExpressionMatch match = regex.match(trimmed);
    if (!match.hasMatch()) {
        if (error)
            *error = tr("Unsupported audio format for Azure.");
        return false;
    }

    const QString type = match.captured(1).toLower();
    const int bits = match.captured(2).toInt();
    const QString endian = match.captured(3).toLower();

    if (!endian.isEmpty() && endian != QStringLiteral("le")) {
        if (error)
            *error = tr("Only little-endian PCM is supported.");
        return false;
    }

    if (sampleType) {
        if (type == QStringLiteral("f"))
            *sampleType = SampleType::Float;
        else if (type == QStringLiteral("u"))
            *sampleType = SampleType::Unsigned;
        else
            *sampleType = SampleType::Signed;
    }

    if (bitsPerSample)
        *bitsPerSample = bits;
    if (littleEndian)
        *littleEndian = true;

    return bits > 0;
}

QByteArray AzureSpeechService::convertToPcm16(const QByteArray &data) const {
    if (inputBitsPerSample <= 0)
        return QByteArray();

    const int bytesPerSample = inputBitsPerSample / 8;
    if (bytesPerSample <= 0)
        return QByteArray();

    const int sampleCount = data.size() / bytesPerSample;
    if (sampleCount <= 0)
        return QByteArray();

    QByteArray out(sampleCount * 2, 0);
    const char *src = data.constData();
    char *dst = out.data();

    auto writeSample = [dst](int index, qint16 value) {
        dst[index * 2] = static_cast<char>(value & 0xff);
        dst[index * 2 + 1] = static_cast<char>((value >> 8) & 0xff);
    };

    switch (inputSampleType) {
        case SampleType::Signed: {
            if (inputBitsPerSample == 8) {
                for (int i = 0; i < sampleCount; ++i) {
                    const qint8 sample = static_cast<qint8>(src[i]);
                    writeSample(i, static_cast<qint16>(sample) << 8);
                }
            } else if (inputBitsPerSample == 16) {
                for (int i = 0; i < sampleCount; ++i) {
                    const int offset = i * 2;
                    const qint16 sample = static_cast<qint16>(
                        static_cast<quint8>(src[offset]) |
                        (static_cast<quint8>(src[offset + 1]) << 8));
                    writeSample(i, sample);
                }
            } else if (inputBitsPerSample == 24) {
                for (int i = 0; i < sampleCount; ++i) {
                    const int offset = i * 3;
                    const quint32 packed = static_cast<quint8>(src[offset]) |
                                           (static_cast<quint8>(src[offset + 1]) << 8) |
                                           (static_cast<quint8>(src[offset + 2]) << 16);
                    qint32 value = (packed & 0x800000)
                                       ? static_cast<qint32>(packed | 0xFF000000)
                                       : static_cast<qint32>(packed);
                    writeSample(i, static_cast<qint16>(value >> 8));
                }
            } else if (inputBitsPerSample == 32) {
                for (int i = 0; i < sampleCount; ++i) {
                    const int offset = i * 4;
                    const qint32 value = static_cast<qint32>(
                        static_cast<quint8>(src[offset]) |
                        (static_cast<quint8>(src[offset + 1]) << 8) |
                        (static_cast<quint8>(src[offset + 2]) << 16) |
                        (static_cast<quint8>(src[offset + 3]) << 24));
                    writeSample(i, static_cast<qint16>(value >> 16));
                }
            } else {
                return QByteArray();
            }
            break;
        }
        case SampleType::Unsigned: {
            if (inputBitsPerSample == 8) {
                for (int i = 0; i < sampleCount; ++i) {
                    const quint8 sample = static_cast<quint8>(src[i]);
                    const qint16 value = static_cast<qint16>(static_cast<int>(sample) - 128) << 8;
                    writeSample(i, value);
                }
            } else if (inputBitsPerSample == 16) {
                for (int i = 0; i < sampleCount; ++i) {
                    const int offset = i * 2;
                    const quint16 sample = static_cast<quint16>(
                        static_cast<quint8>(src[offset]) |
                        (static_cast<quint8>(src[offset + 1]) << 8));
                    const qint32 value = static_cast<qint32>(sample) - 32768;
                    writeSample(i, static_cast<qint16>(value));
                }
            } else if (inputBitsPerSample == 24) {
                for (int i = 0; i < sampleCount; ++i) {
                    const int offset = i * 3;
                    const quint32 sample = static_cast<quint8>(src[offset]) |
                                           (static_cast<quint8>(src[offset + 1]) << 8) |
                                           (static_cast<quint8>(src[offset + 2]) << 16);
                    const qint32 value = static_cast<qint32>(sample) - 0x800000;
                    writeSample(i, static_cast<qint16>(value >> 8));
                }
            } else if (inputBitsPerSample == 32) {
                for (int i = 0; i < sampleCount; ++i) {
                    const int offset = i * 4;
                    const quint32 sample = static_cast<quint32>(
                        static_cast<quint8>(src[offset]) |
                        (static_cast<quint8>(src[offset + 1]) << 8) |
                        (static_cast<quint8>(src[offset + 2]) << 16) |
                        (static_cast<quint8>(src[offset + 3]) << 24));
                    const qint64 value = static_cast<qint64>(sample) - 0x80000000LL;
                    writeSample(i, static_cast<qint16>(value >> 16));
                }
            } else {
                return QByteArray();
            }
            break;
        }
        case SampleType::Float: {
            if (inputBitsPerSample == 32) {
                for (int i = 0; i < sampleCount; ++i) {
                    const int offset = i * 4;
                    float value = 0.0f;
                    memcpy(&value, src + offset, sizeof(float));
                    const float clamped = qBound(-1.0f, value, 1.0f);
                    writeSample(i, static_cast<qint16>(clamped * 32767.0f));
                }
            } else if (inputBitsPerSample == 64) {
                for (int i = 0; i < sampleCount; ++i) {
                    const int offset = i * 8;
                    double value = 0.0;
                    memcpy(&value, src + offset, sizeof(double));
                    const double clamped = qBound(-1.0, value, 1.0);
                    writeSample(i, static_cast<qint16>(clamped * 32767.0));
                }
            } else {
                return QByteArray();
            }
            break;
        }
    }

    return out;
}

QUrl AzureSpeechService::buildServiceUrl(const AzureSettings &settings, const QString &connectionId) const {
    QString endpoint = settings.endpoint.trimmed();
    if (endpoint.isEmpty()) {
        endpoint = QStringLiteral("wss://eastus.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1");
    }

    QUrl url(endpoint);
    if (url.scheme().isEmpty())
        url = QUrl(QStringLiteral("wss://") + endpoint);
    if (url.scheme().compare(QStringLiteral("https"), Qt::CaseInsensitive) == 0)
        url.setScheme(QStringLiteral("wss"));
    if (url.scheme().compare(QStringLiteral("http"), Qt::CaseInsensitive) == 0)
        url.setScheme(QStringLiteral("ws"));

    if (!url.isValid())
        return QUrl();

    QUrlQuery query(url);

    if (!settings.endpointId.trimmed().isEmpty() && !query.hasQueryItem(QStringLiteral("cid")))
        query.addQueryItem(QStringLiteral("cid"), settings.endpointId.trimmed());

    if (!query.hasQueryItem(QStringLiteral("format")))
        query.addQueryItem(QStringLiteral("format"), QStringLiteral("simple"));

    const QStringList languageHints = splitList(settings.languageHints);
    const bool autoDetect = settings.languageHintsStrict && !languageHints.isEmpty()
                            && !query.hasQueryItem(QStringLiteral("language"));
    if (autoDetect) {
        if (!query.hasQueryItem(QStringLiteral("lidEnabled")))
            query.addQueryItem(QStringLiteral("lidEnabled"), QStringLiteral("true"));
    } else if (!settings.language.trimmed().isEmpty() && !query.hasQueryItem(QStringLiteral("language"))) {
        query.addQueryItem(QStringLiteral("language"), settings.language.trimmed());
    }

    if (!query.hasQueryItem(QStringLiteral("Ocp-Apim-Subscription-Key")))
        query.addQueryItem(QStringLiteral("Ocp-Apim-Subscription-Key"), settings.apiKey.trimmed());

    if (!connectionId.isEmpty() && !query.hasQueryItem(QStringLiteral("X-ConnectionId")))
        query.addQueryItem(QStringLiteral("X-ConnectionId"), connectionId);

    url.setQuery(query);
    return url;
}

QString AzureSpeechService::buildTextMessage(const QString &path, const QString &requestId,
                                             const QString &contentType, const QString &body) const {
    QString message;
    message += QStringLiteral("Path: ") + path + QStringLiteral("\r\n");
    message += QStringLiteral("X-RequestId: ") + requestId + QStringLiteral("\r\n");
    message += QStringLiteral("X-Timestamp: ")
               + QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs)
               + QStringLiteral("\r\n");
    if (!contentType.isEmpty()) {
        message += QStringLiteral("Content-Type: ") + contentType + QStringLiteral("\r\n");
    }
    message += QStringLiteral("\r\n");
    message += body;
    return message;
}

QByteArray AzureSpeechService::buildBinaryMessage(const QString &path, const QString &requestId,
                                                  const QString &contentType, const QByteArray &body) const {
    QString headers;
    headers += QStringLiteral("Path: ") + path + QStringLiteral("\r\n");
    headers += QStringLiteral("X-RequestId: ") + requestId + QStringLiteral("\r\n");
    headers += QStringLiteral("X-Timestamp: ")
               + QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs)
               + QStringLiteral("\r\n");
    if (!contentType.isEmpty())
        headers += QStringLiteral("Content-Type: ") + contentType + QStringLiteral("\r\n");

    const QByteArray headerBytes = headers.toUtf8();
    const quint16 headerLength = static_cast<quint16>(headerBytes.size());
    QByteArray payload;
    payload.resize(2 + headerLength + body.size());
    payload[0] = static_cast<char>((headerLength >> 8) & 0xff);
    payload[1] = static_cast<char>(headerLength & 0xff);
    memcpy(payload.data() + 2, headerBytes.constData(), headerBytes.size());
    if (!body.isEmpty())
        memcpy(payload.data() + 2 + headerBytes.size(), body.constData(), body.size());
    return payload;
}

QMap<QString, QString> AzureSpeechService::parseHeaders(const QString &headerBlock) const {
    QMap<QString, QString> headers;
    if (headerBlock.isEmpty())
        return headers;

    const QStringList lines = headerBlock.split(QStringLiteral("\r\n"), Qt::SkipEmptyParts);
    for (const auto &line : lines) {
        const int separator = line.indexOf(QLatin1Char(':'));
        if (separator <= 0)
            continue;
        const QString name = line.left(separator).trimmed().toLower();
        const QString value = line.mid(separator + 1).trimmed();
        if (!name.isEmpty())
            headers.insert(name, value);
    }
    return headers;
}

QString AzureSpeechService::extractResultText(const QJsonObject &root) const {
    QString text = root.value(QStringLiteral("DisplayText")).toString();
    if (text.isEmpty())
        text = root.value(QStringLiteral("Text")).toString();
    if (text.isEmpty()) {
        const QJsonArray nbest = root.value(QStringLiteral("NBest")).toArray();
        if (!nbest.isEmpty()) {
            const QJsonObject best = nbest.at(0).toObject();
            text = best.value(QStringLiteral("Display")).toString();
            if (text.isEmpty())
                text = best.value(QStringLiteral("DisplayText")).toString();
            if (text.isEmpty())
                text = best.value(QStringLiteral("Lexical")).toString();
            if (text.isEmpty())
                text = best.value(QStringLiteral("ITN")).toString();
        }
    }
    return text.trimmed();
}

QString AzureSpeechService::extractErrorText(const QJsonObject &root) const {
    const QString status = root.value(QStringLiteral("RecognitionStatus")).toString();
    if (status.isEmpty())
        return QString();

    const QString lower = status.toLower();
    if (lower == QStringLiteral("error") ||
        lower == QStringLiteral("badrequest") ||
        lower == QStringLiteral("forbidden") ||
        lower == QStringLiteral("toomanyrequests")) {
        QString details = root.value(QStringLiteral("ErrorDetails")).toString();
        if (details.isEmpty())
            details = root.value(QStringLiteral("errorDetails")).toString();
        if (details.isEmpty())
            details = status;
        return details;
    }
    return QString();
}

void AzureSpeechService::appendCommittedText(const QString &text) {
    if (text.isEmpty())
        return;
    if (!committedText.isEmpty() && !committedText.endsWith(QLatin1Char(' '))
        && !text.startsWith(QLatin1Char(' '))) {
        committedText += QLatin1Char(' ');
    }
    committedText += text;
}

void AzureSpeechService::emitTranscript() {
    QString fullText = committedText;
    if (!currentText.isEmpty()) {
        if (!fullText.isEmpty() && !fullText.endsWith(QLatin1Char(' '))
            && !currentText.startsWith(QLatin1Char(' '))) {
            fullText += QLatin1Char(' ');
        }
        fullText += currentText;
    }
    if (!fullText.isEmpty())
        emit transcriptUpdated(fullText);
}