pjsipua-win 0.1.26

// src/pjsua2_wrapper.cpp - Pure PJSUA2 implementation without mixed APIs
#include <pjsua2.hpp>
#include <iostream>
#include <memory>
#include <atomic>
#include <mutex>
#include <map>
#ifdef _WIN32
#include <windows.h>
#endif
#include "pjsua2_wrapper.h"

using namespace pj;

namespace {
    std::atomic<bool> g_initialized{false};
    std::unique_ptr<Endpoint> g_endpoint;
    std::mutex g_mutex;
    std::map<int, std::shared_ptr<Account>> g_accounts;
    std::map<int, std::shared_ptr<Call>> g_calls;
    std::map<int, bool> g_call_mute_status;  // Track mute status per call
    std::map<int, int> g_call_conf_slots;    // Track conference slots per call
    std::atomic<int> g_next_account_id{0};

    // Global callback function pointers
    void (*g_on_reg_state)(int acc_id, int is_registered) = nullptr;
    void (*g_on_incoming_call)(int acc_id, int call_id, const char* remote_uri) = nullptr;
    void (*g_on_call_state)(int call_id, int state) = nullptr;
    void (*g_on_call_media_state)(int call_id, int state) = nullptr;
}

// Forward declaration
class MyCall;

// Custom Account class with callback support
class MyAccount : public Account {
private:
    int m_id;

public:
    MyAccount(int id) : m_id(id) {}

    virtual ~MyAccount() {}

    // Override registration state callback
    virtual void onRegState(OnRegStateParam &/*prm*/) {
        std::cout << "[PJSUA2] Account " << m_id << " registration state changed\n";

        AccountInfo ai = getInfo();
        bool registered = ai.regIsActive;

        std::cout << "[PJSUA2] Registration status: " << (registered ? "registered" : "not registered") << "\n";

        // Call the global callback if set
        if (g_on_reg_state) {
            std::cout << "[PJSUA2] Calling registration callback for account " << m_id
                      << " (callback ptr: " << (void*)g_on_reg_state << ")\n";
            g_on_reg_state(m_id, registered ? 1 : 0);
        } else {
            std::cout << "[PJSUA2] No registration callback set (g_on_reg_state is null)\n";
        }
    }

    // Override incoming call callback
    virtual void onIncomingCall(OnIncomingCallParam &iprm);  // Implementation after MyCall definition
};

// Custom Call class to handle media state
class MyCall : public Call {
private:
    Account &m_acc;

public:
    MyCall(Account &acc, int call_id = PJSUA_INVALID_ID) : Call(acc, call_id), m_acc(acc) {}

    virtual ~MyCall() {}

    // Override to handle call state changes
    virtual void onCallState(OnCallStateParam &/*prm*/) {
        CallInfo ci = getInfo();

        if (g_on_call_state) {
            g_on_call_state(ci.id, ci.state);
        }

        // Clean up if disconnected
        if (ci.state == PJSIP_INV_STATE_DISCONNECTED) {
            // Remove from our map
            auto it = g_calls.find(ci.id);
            if (it != g_calls.end()) {
                g_calls.erase(it);
                std::cout << "[PJSUA2] Call " << ci.id << " removed from calls map\n";
            }
            // Clean up mute status and conf slot
            g_call_mute_status.erase(ci.id);
            g_call_conf_slots.erase(ci.id);
        }
    }

    // Override to handle media state changes
    virtual void onCallMediaState(OnCallMediaStateParam &/*prm*/) {
        CallInfo ci = getInfo();

        // Check if media is active
        bool has_media = false;
        for (unsigned i = 0; i < ci.media.size(); i++) {
            if (ci.media[i].type == PJMEDIA_TYPE_AUDIO &&
                ci.media[i].status == PJSUA_CALL_MEDIA_ACTIVE) {
                has_media = true;

                // Get audio media
                AudioMedia* aud_med = nullptr;
                try {
                    aud_med = static_cast<AudioMedia*>(getMedia(i));
                } catch(...) {
                    std::cout << "[PJSUA2] Failed to get audio media for index " << i << "\n";
                    continue;
                }

                if (aud_med) {
                    // Store conference slot for this call
                    g_call_conf_slots[ci.id] = aud_med->getPortId();

                    // Connect to sound device
                    AudDevManager& mgr = Endpoint::instance().audDevManager();

                    try {
                        // Connect call audio to speaker
                        aud_med->startTransmit(mgr.getPlaybackDevMedia());

                        // Connect microphone to call (unless muted)
                        if (g_call_mute_status.find(ci.id) == g_call_mute_status.end() ||
                            !g_call_mute_status[ci.id]) {
                            mgr.getCaptureDevMedia().startTransmit(*aud_med);
                        }

                        std::cout << "[PJSUA2] Audio media connected for call " << ci.id << "\n";
                    } catch (Error& err) {
                        std::cerr << "[PJSUA2] Failed to connect audio: " << err.reason << "\n";
                    }
                }

                break;
            }
        }

        if (g_on_call_media_state) {
            g_on_call_media_state(ci.id, has_media ? 1 : 0);
        }
    }
};

// Implementation of MyAccount::onIncomingCall
void MyAccount::onIncomingCall(OnIncomingCallParam &iprm) {
    std::cout << "[PJSUA2] Incoming call to account " << m_id << "\n";

    // Use MyCall for proper callbacks
    MyCall *call = new MyCall(*this, iprm.callId);
    int call_id = call->getId();
    CallInfo ci = call->getInfo();

    // Store in global map BEFORE calling callback
    g_calls[call_id] = std::shared_ptr<Call>(call);

    std::cout << "[PJSUA2] Call " << call_id << " added to calls map\n";

    if (g_on_incoming_call) {
        g_on_incoming_call(m_id, call_id, ci.remoteUri.c_str());
    }
}

extern "C" {

int pjsua2_create_endpoint() {
    std::lock_guard<std::mutex> lock(g_mutex);

    if (g_initialized.load()) {
        return 0;
    }

    try {
        g_endpoint = std::make_unique<Endpoint>();
        g_endpoint->libCreate();
        g_initialized.store(true);
        std::cout << "[PJSUA2] Endpoint created\n";
        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error: " << err.reason << "\n";
        return -1;
    }
}

int pjsua2_init_endpoint(int log_level) {
    std::lock_guard<std::mutex> lock(g_mutex);

    if (!g_initialized.load() || !g_endpoint) {
        return -1;
    }

    try {
        EpConfig cfg;
        cfg.logConfig.level = log_level;
        cfg.logConfig.consoleLevel = log_level;

        #ifdef _WIN32
        char tempPath[MAX_PATH];
        if (GetTempPathA(MAX_PATH, tempPath)) {
            cfg.logConfig.filename = std::string(tempPath) + "pjsua2_test.log";
        }
        #endif

        cfg.uaConfig.userAgent = "PJSUA2-Test/1.0";
        cfg.uaConfig.maxCalls = 32;

        // Configure NAT settings for better compatibility
        cfg.uaConfig.natTypeInSdp = 1;

        // Configure STUN servers before initialization
        cfg.uaConfig.stunServer.push_back("stun.l.google.com:19302");
        cfg.uaConfig.stunServer.push_back("stun1.l.google.com:19302");

        // Media configuration for better NAT traversal
        cfg.medConfig.hasIoqueue = true;
        cfg.medConfig.threadCnt = 2;
        cfg.medConfig.quality = 8;
        cfg.medConfig.ptime = 20;
        cfg.medConfig.noVad = false;
        cfg.medConfig.ilbcMode = 30;
        cfg.medConfig.txDropPct = 0;
        cfg.medConfig.rxDropPct = 0;
        cfg.medConfig.ecOptions = PJMEDIA_ECHO_DEFAULT;
        cfg.medConfig.ecTailLen = 200;

        g_endpoint->libInit(cfg);

        std::cout << "[PJSUA2] Endpoint initialized with STUN servers and NAT config (max calls: 32)\n";

        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error: " << err.reason << "\n";
        return -1;
    } catch (std::exception& e) {
        std::cerr << "[PJSUA2] Exception: " << e.what() << "\n";
        return -1;
    } catch (...) {
        std::cerr << "[PJSUA2] Unknown exception\n";
        return -1;
    }
}

int pjsua2_create_transport(int port) {
    std::lock_guard<std::mutex> lock(g_mutex);

    if (!g_initialized.load() || !g_endpoint) {
        return -1;
    }

    try {
        TransportConfig tcfg;
        tcfg.port = port;

        g_endpoint->transportCreate(PJSIP_TRANSPORT_UDP, tcfg);
        std::cout << "[PJSUA2] Transport created on port " << port << "\n";
        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error: " << err.reason << "\n";
        return -1;
    }
}

int pjsua2_start() {
    std::lock_guard<std::mutex> lock(g_mutex);

    if (!g_initialized.load() || !g_endpoint) {
        return -1;
    }

    try {
        g_endpoint->libStart();
        std::cout << "[PJSUA2] Started\n";
        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error: " << err.reason << "\n";
        return -1;
    }
}

void pjsua2_destroy() {
    std::lock_guard<std::mutex> lock(g_mutex);

    if (!g_initialized.load() || !g_endpoint) {
        return;
    }

    try {
        g_accounts.clear();
        g_calls.clear();
        g_call_mute_status.clear();
        g_call_conf_slots.clear();
        g_endpoint->libDestroy();
        g_endpoint.reset();
        g_initialized.store(false);
        std::cout << "[PJSUA2] Destroyed\n";
    } catch (...) {
        g_endpoint.reset();
        g_initialized.store(false);
    }
}

int pjsua2_create_account_simple(const char* id_uri, const char* registrar_uri,
                                const char* username, const char* password) {
    std::cout << "[PJSUA2] create_account_simple called\n";
    std::cout << "[PJSUA2]   id_uri: " << (id_uri ? id_uri : "null") << "\n";
    std::cout << "[PJSUA2]   registrar_uri: " << (registrar_uri ? registrar_uri : "null") << "\n";
    std::cout << "[PJSUA2]   username: " << (username ? username : "null") << "\n";
    std::cout << "[PJSUA2]   password: " << (password ? "***" : "null") << "\n";

    if (!id_uri || !registrar_uri || !username || !password) {
        std::cerr << "[PJSUA2] Invalid parameters - null pointer(s)\n";
        return -1;
    }

    std::cout << "[PJSUA2] Acquiring lock...\n";
    std::lock_guard<std::mutex> lock(g_mutex);
    std::cout << "[PJSUA2] Lock acquired\n";

    if (!g_initialized.load()) {
        std::cerr << "[PJSUA2] Not initialized\n";
        return -1;
    }

    if (!g_endpoint) {
        std::cerr << "[PJSUA2] Endpoint is null\n";
        return -1;
    }

    // Check endpoint state
    try {
        pjsua_state state = g_endpoint->libGetState();
        std::cout << "[PJSUA2] Endpoint state: " << state << "\n";
        if (state != PJSUA_STATE_RUNNING) {
            std::cerr << "[PJSUA2] Endpoint not in RUNNING state (state=" << state << ")\n";
            return -1;
        }
    } catch (...) {
        std::cerr << "[PJSUA2] Failed to get endpoint state\n";
        return -1;
    }

    // Skip transport verification - if we got here, transport should be OK
    std::cout << "[PJSUA2] Skipping transport verification (endpoint is running)\n";

    try {
        std::cout << "[PJSUA2] Creating AccountConfig...\n";
        AccountConfig cfg;

        // Set URIs with validation
        std::cout << "[PJSUA2] Setting idUri...\n";
        cfg.idUri = id_uri;

        std::cout << "[PJSUA2] Setting registrarUri...\n";
        cfg.regConfig.registrarUri = registrar_uri;

        // Add timeout settings
        cfg.regConfig.timeoutSec = 60;
        cfg.regConfig.retryIntervalSec = 30;
        cfg.regConfig.firstRetryIntervalSec = 5;

        // Disable certain features that might cause issues
        cfg.presConfig.publishEnabled = false;
        cfg.mwiConfig.enabled = false;
        cfg.natConfig.contactRewriteUse = 1; // Always rewrite contact

        std::cout << "[PJSUA2] Creating AuthCredInfo...\n";
        AuthCredInfo cred;
        cred.scheme = "digest";
        cred.realm = "*";
        cred.username = username;
        cred.dataType = 0;
        cred.data = password;

        std::cout << "[PJSUA2] Adding credentials to config...\n";
        cfg.sipConfig.authCreds.clear();
        cfg.sipConfig.authCreds.push_back(cred);

        // Simple NAT config - don't use ICE initially
        std::cout << "[PJSUA2] Configuring NAT settings (simplified)...\n";
        cfg.natConfig.iceEnabled = false; // Disable ICE for now
        cfg.natConfig.sipStunUse = PJSUA_STUN_USE_DEFAULT;
        cfg.natConfig.mediaStunUse = PJSUA_STUN_USE_DEFAULT;

        std::cout << "[PJSUA2] Getting next account ID...\n";
        int id = g_next_account_id.fetch_add(1);
        std::cout << "[PJSUA2] Account ID will be: " << id << "\n";

        std::cout << "[PJSUA2] Creating MyAccount object...\n";
        MyAccount* acc_ptr = nullptr;
        try {
            acc_ptr = new MyAccount(id);
            std::cout << "[PJSUA2] MyAccount object created at " << (void*)acc_ptr << "\n";
        } catch (std::exception& e) {
            std::cerr << "[PJSUA2] Failed to create MyAccount object: " << e.what() << "\n";
            return -1;
        } catch (...) {
            std::cerr << "[PJSUA2] Failed to create MyAccount object: unknown exception\n";
            return -1;
        }

        // Don't use shared_ptr yet, just raw pointer
        std::cout << "[PJSUA2] Creating account with PJSUA2...\n";
        try {
            std::cout << "[PJSUA2] About to call acc->create()...\n";
            acc_ptr->create(cfg);
            std::cout << "[PJSUA2] acc->create() returned successfully\n";
        } catch (Error& err) {
            std::cerr << "[PJSUA2] PJSUA2 Error in acc->create(): " << err.reason << "\n";
            std::cerr << "[PJSUA2] Error status: " << err.status << "\n";
            std::cerr << "[PJSUA2] Error title: " << err.title << "\n";
            std::cerr << "[PJSUA2] Error srcFile: " << err.srcFile << "\n";
            std::cerr << "[PJSUA2] Error srcLine: " << err.srcLine << "\n";
            delete acc_ptr;
            return -1;
        } catch (std::exception& e) {
            std::cerr << "[PJSUA2] std::exception in acc->create(): " << e.what() << "\n";
            delete acc_ptr;
            return -1;
        } catch (...) {
            std::cerr << "[PJSUA2] Unknown exception in acc->create()\n";
            delete acc_ptr;
            return -1;
        }

        // Now create shared_ptr
        std::cout << "[PJSUA2] Creating shared_ptr for account...\n";
        auto acc = std::shared_ptr<MyAccount>(acc_ptr);

        std::cout << "[PJSUA2] Storing account in map...\n";
        g_accounts[id] = acc;

        std::cout << "[PJSUA2] Account created with ID " << id << "\n";
        std::cout << "[PJSUA2] Total accounts: " << g_accounts.size() << "\n";

        // Verify account was created properly
        try {
            AccountInfo ai = acc->getInfo();
            std::cout << "[PJSUA2] Account info - URI: " << ai.uri << "\n";
            std::cout << "[PJSUA2] Account info - regIsActive: " << ai.regIsActive << "\n";
        } catch (...) {
            std::cout << "[PJSUA2] Warning: Could not get account info\n";
        }

        return id;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] PJSUA2 Error (outer): " << err.reason << "\n";
        std::cerr << "[PJSUA2] Error status: " << err.status << "\n";
        return -1;
    } catch (std::exception& e) {
        std::cerr << "[PJSUA2] std::exception (outer): " << e.what() << "\n";
        return -1;
    } catch (...) {
        std::cerr << "[PJSUA2] Unknown exception in create_account_simple (outer)\n";
        return -1;
    }
}

// Also add this helper function to verify endpoint is ready:
int pjsua2_check_ready() {
    if (!g_initialized.load() || !g_endpoint) {
        return -1;
    }

    try {
        pjsua_state state = g_endpoint->libGetState();
        return (state == PJSUA_STATE_RUNNING) ? 0 : -1;
    } catch (...) {
        return -1;
    }
}

// Create account with callbacks - now just uses the simple version since we have global callbacks
int pjsua2_create_account(const char* id_uri, const char* registrar_uri,
                         const char* username, const char* password,
                         void (*on_reg_state)(int is_registered),
                         void (*on_incoming_call)(int call_id, const char* remote_uri)) {
    // Callbacks are now global, so we ignore the per-account ones
    return pjsua2_create_account_simple(id_uri, registrar_uri, username, password);
}

// Call management
int pjsua2_make_call(int acc_id, const char* dst_uri) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_accounts.find(acc_id);
    if (it == g_accounts.end()) {
        return -1;
    }

    try {
        // Use MyCall instead of Call for proper callbacks
        MyCall* call = new MyCall(*it->second);
        CallOpParam prm;
        prm.opt.audioCount = 1;
        prm.opt.videoCount = 0;

        call->makeCall(dst_uri, prm);

        int call_id = call->getId();
        g_calls[call_id] = std::shared_ptr<Call>(call);

        std::cout << "[PJSUA2] Call initiated: " << call_id << "\n";
        return call_id;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error: " << err.reason << "\n";
        return -1;
    }
}

// Enhanced answer function with proper audio connection
int pjsua2_answer_call(int call_id, int code) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        return -1;
    }

    try {
        CallOpParam prm;
        prm.statusCode = (pjsip_status_code)code;
        prm.opt.audioCount = 1;
        prm.opt.videoCount = 0;

        // IMPORTANT: Set flags for NAT traversal
        prm.opt.flag |= PJSUA_CALL_UNHOLD;  // Make sure call is not on hold
        prm.opt.flag |= PJSUA_CALL_UPDATE_CONTACT; // Update contact with discovered IP

        it->second->answer(prm);

        // Audio connection is handled in onCallMediaState callback
        std::cout << "[PJSUA2] Call " << call_id << " answered\n";
        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error: " << err.reason << "\n";
        return -1;
    }
}

int pjsua2_hangup_call(int call_id) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        return -1;
    }

    try {
        CallOpParam prm;
        it->second->hangup(prm);
        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error: " << err.reason << "\n";
        return -1;
    }
}

// Hold/Unhold implementation
int pjsua2_hold_call(int call_id) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        return -1;
    }

    try {
        CallOpParam prm;
        it->second->setHold(prm);
        std::cout << "[PJSUA2] Call " << call_id << " put on hold\n";
        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error holding call: " << err.reason << "\n";
        return -1;
    }
}

int pjsua2_unhold_call(int call_id) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        return -1;
    }

    try {
        CallOpParam prm;
        prm.opt.flag = PJSUA_CALL_UNHOLD;
        prm.opt.audioCount = 1;
        it->second->reinvite(prm);
        std::cout << "[PJSUA2] Call " << call_id << " resumed from hold\n";
        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error unholding call: " << err.reason << "\n";
        return -1;
    }
}

int pjsua2_is_call_on_hold(int call_id) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        return 0;
    }

    try {
        CallInfo ci = it->second->getInfo();
        // Check if media is on hold
        for (unsigned i = 0; i < ci.media.size(); i++) {
            if (ci.media[i].type == PJMEDIA_TYPE_AUDIO) {
                return (ci.media[i].dir == PJMEDIA_DIR_NONE ||
                        ci.media[i].status == PJSUA_CALL_MEDIA_LOCAL_HOLD ||
                        ci.media[i].status == PJSUA_CALL_MEDIA_REMOTE_HOLD) ? 1 : 0;
            }
        }
        return 0;
    } catch (...) {
        return 0;
    }
}

// Mute/Unmute implementation using PJSUA2 APIs
int pjsua2_mute_call(int call_id, int mute) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        return -1;
    }

    try {
        CallInfo ci = it->second->getInfo();

        // Find active audio media
        for (unsigned i = 0; i < ci.media.size(); i++) {
            if (ci.media[i].type == PJMEDIA_TYPE_AUDIO &&
                ci.media[i].status == PJSUA_CALL_MEDIA_ACTIVE) {

                AudioMedia* aud_med = nullptr;
                try {
                    aud_med = static_cast<AudioMedia*>(it->second->getMedia(i));
                } catch(...) {
                    continue;
                }

                if (aud_med) {
                    AudDevManager& mgr = g_endpoint->audDevManager();

                    if (mute) {
                        // Stop transmitting from microphone to call
                        try {
                            mgr.getCaptureDevMedia().stopTransmit(*aud_med);
                            g_call_mute_status[call_id] = true;
                            std::cout << "[PJSUA2] Call " << call_id << " muted\n";
                        } catch (Error& err) {
                            std::cerr << "[PJSUA2] Error muting call: " << err.reason << "\n";
                            return -1;
                        }
                    } else {
                        // Resume transmitting from microphone to call
                        try {
                            mgr.getCaptureDevMedia().startTransmit(*aud_med);
                            g_call_mute_status[call_id] = false;
                            std::cout << "[PJSUA2] Call " << call_id << " unmuted\n";
                        } catch (Error& err) {
                            std::cerr << "[PJSUA2] Error unmuting call: " << err.reason << "\n";
                            return -1;
                        }
                    }

                    return 0;
                }
            }
        }

        std::cerr << "[PJSUA2] No active audio media found for call " << call_id << "\n";
        return -1;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error muting/unmuting call: " << err.reason << "\n";
        return -1;
    }
}

int pjsua2_is_call_muted(int call_id) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_call_mute_status.find(call_id);
    if (it != g_call_mute_status.end()) {
        return it->second ? 1 : 0;
    }
    return 0;
}

// DTMF implementation using PJSUA2
int pjsua2_send_dtmf(int call_id, const char* digits) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        return -1;
    }

    try {
        CallInfo ci = it->second->getInfo();

        // Check if call is connected
        if (ci.state != PJSIP_INV_STATE_CONFIRMED) {
            std::cerr << "[PJSUA2] Call not in confirmed state, cannot send DTMF\n";
            return -1;
        }

        // Use PJSUA2 Call::dialDtmf
        it->second->dialDtmf(digits);

        std::cout << "[PJSUA2] Sent DTMF '" << digits << "' on call " << call_id << "\n";
        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error sending DTMF: " << err.reason << "\n";
        return -1;
    }
}

// Conference implementation using PJSUA2
int pjsua2_conference_calls(int call_id1, int call_id2) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it1 = g_calls.find(call_id1);
    auto it2 = g_calls.find(call_id2);

    if (it1 == g_calls.end() || it2 == g_calls.end()) {
        return -1;
    }

    try {
        // Get audio media for both calls
        AudioMedia* aud_med1 = nullptr;
        AudioMedia* aud_med2 = nullptr;

        // Get media for call 1
        CallInfo ci1 = it1->second->getInfo();
        for (unsigned i = 0; i < ci1.media.size(); i++) {
            if (ci1.media[i].type == PJMEDIA_TYPE_AUDIO &&
                ci1.media[i].status == PJSUA_CALL_MEDIA_ACTIVE) {
                aud_med1 = static_cast<AudioMedia*>(it1->second->getMedia(i));
                break;
            }
        }

        // Get media for call 2
        CallInfo ci2 = it2->second->getInfo();
        for (unsigned i = 0; i < ci2.media.size(); i++) {
            if (ci2.media[i].type == PJMEDIA_TYPE_AUDIO &&
                ci2.media[i].status == PJSUA_CALL_MEDIA_ACTIVE) {
                aud_med2 = static_cast<AudioMedia*>(it2->second->getMedia(i));
                break;
            }
        }

        if (!aud_med1 || !aud_med2) {
            std::cerr << "[PJSUA2] Could not get audio media for one or both calls\n";
            return -1;
        }

        // Bridge the calls together
        aud_med1->startTransmit(*aud_med2);
        aud_med2->startTransmit(*aud_med1);

        std::cout << "[PJSUA2] Conferenced calls " << call_id1 << " and " << call_id2 << "\n";
        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error conferencing calls: " << err.reason << "\n";
        return -1;
    }
}

int pjsua2_get_conf_port(int call_id) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_call_conf_slots.find(call_id);
    if (it != g_call_conf_slots.end()) {
        return it->second;
    }

    // Try to get it from call info
    auto call_it = g_calls.find(call_id);
    if (call_it != g_calls.end()) {
        try {
            CallInfo ci = call_it->second->getInfo();
            for (unsigned i = 0; i < ci.media.size(); i++) {
                if (ci.media[i].type == PJMEDIA_TYPE_AUDIO &&
                    ci.media[i].status == PJSUA_CALL_MEDIA_ACTIVE) {
                    AudioMedia* aud_med = static_cast<AudioMedia*>(call_it->second->getMedia(i));
                    if (aud_med) {
                        int port_id = aud_med->getPortId();
                        g_call_conf_slots[call_id] = port_id;
                        return port_id;
                    }
                }
            }
        } catch (...) {
        }
    }

    return -1;
}

// Get detailed call info
int pjsua2_get_call_detailed_info(int call_id,
                                  int* is_on_hold,
                                  int* is_muted,
                                  int* conf_port) {
    std::lock_guard<std::mutex> lock(g_mutex);

    // Initialize output parameters to safe defaults
    if (is_on_hold) *is_on_hold = 0;
    if (is_muted) *is_muted = 0;
    if (conf_port) *conf_port = -1;

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        std::cout << "[PJSUA2] Call " << call_id << " not found in calls map\n";
        return -1;
    }

    try {
        // First check if the call object is valid
        if (!it->second || !it->second->isActive()) {
            std::cout << "[PJSUA2] Call " << call_id << " is not active\n";
            return -1;
        }

        // Get call info
        CallInfo ci;
        try {
            ci = it->second->getInfo();
        } catch (Error& err) {
            std::cerr << "[PJSUA2] Error getting call info: " << err.reason << "\n";
            return -1;
        } catch (...) {
            std::cerr << "[PJSUA2] Unknown error getting call info\n";
            return -1;
        }

        // Check if call is in a state where we can safely get detailed info
        if (ci.state < PJSIP_INV_STATE_CONFIRMED && ci.state != PJSIP_INV_STATE_DISCONNECTED) {
            std::cout << "[PJSUA2] Call " << call_id << " is in state " << ci.state
                      << ", not safe to get detailed info\n";
            return -2; // Special return code for "call not ready"
        }

        // Get hold status
        if (is_on_hold) {
            try {
                *is_on_hold = pjsua2_is_call_on_hold(call_id);
            } catch (...) {
                *is_on_hold = 0;
            }
        }

        // Get mute status
        if (is_muted) {
            try {
                *is_muted = pjsua2_is_call_muted(call_id);
            } catch (...) {
                *is_muted = 0;
            }
        }

        // Get conference port
        if (conf_port) {
            try {
                *conf_port = pjsua2_get_conf_port(call_id);
            } catch (...) {
                *conf_port = -1;
            }
        }

        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Exception in get_call_detailed_info: " << err.reason << "\n";
        return -1;
    } catch (std::exception& e) {
        std::cerr << "[PJSUA2] std::exception in get_call_detailed_info: " << e.what() << "\n";
        return -1;
    } catch (...) {
        std::cerr << "[PJSUA2] Unknown exception in get_call_detailed_info\n";
        return -1;
    }
}

// Audio devices
int pjsua2_get_audio_device_count() {
    if (!g_initialized.load() || !g_endpoint) {
        return 0;
    }

    try {
        AudDevManager& mgr = g_endpoint->audDevManager();
        const AudioDevInfoVector2 devs = mgr.enumDev2();
        return static_cast<int>(devs.size());
    } catch (...) {
        return 0;
    }
}

int pjsua2_get_audio_device_info(int index, char* name, int name_size,
                                int* is_capture, int* is_playback) {
    if (!g_initialized.load() || !g_endpoint) {
        return -1;
    }

    try {
        AudDevManager& mgr = g_endpoint->audDevManager();
        const AudioDevInfoVector2 devs = mgr.enumDev2();

        if (index < 0 || index >= (int)devs.size()) {
            return -1;
        }

        strncpy(name, devs[index].name.c_str(), name_size - 1);
        name[name_size - 1] = '\0';

        *is_capture = devs[index].inputCount > 0 ? 1 : 0;
        *is_playback = devs[index].outputCount > 0 ? 1 : 0;

        return devs[index].id;
    } catch (...) {
        return -1;
    }
}

int pjsua2_set_audio_devices(int capture_dev, int playback_dev) {
    if (!g_initialized.load() || !g_endpoint) {
        return -1;
    }

    try {
        AudDevManager& mgr = g_endpoint->audDevManager();

        // Validate device IDs first
        if (capture_dev < -1 || playback_dev < -1) {
            std::cerr << "[PJSUA2] Invalid device IDs - capture: " << capture_dev
                      << ", playback: " << playback_dev << "\n";
            return -1;
        }

        // Get current devices to see if we need to change anything
        int current_capture = -1;
        int current_playback = -1;

        try {
            current_capture = mgr.getCaptureDev();
            current_playback = mgr.getPlaybackDev();
        } catch (...) {
            // Ignore errors getting current devices
        }

        std::cout << "[PJSUA2] Current devices - capture: " << current_capture
                  << ", playback: " << current_playback << "\n";

        bool changed = false;

        // Set capture device if different
        if (capture_dev >= 0 && capture_dev != current_capture) {
            try {
                mgr.setCaptureDev(capture_dev);
                changed = true;
                std::cout << "[PJSUA2] Set capture device to: " << capture_dev << "\n";
            } catch (Error& err) {
                std::cerr << "[PJSUA2] Error setting capture device: " << err.reason << "\n";
                return -1;
            }
        }

        // Set playback device if different
        if (playback_dev >= 0 && playback_dev != current_playback) {
            try {
                mgr.setPlaybackDev(playback_dev);
                changed = true;
                std::cout << "[PJSUA2] Set playback device to: " << playback_dev << "\n";
            } catch (Error& err) {
                std::cerr << "[PJSUA2] Error setting playback device: " << err.reason << "\n";
                // Try to restore capture device if playback failed
                if (changed && current_capture >= 0) {
                    try {
                        mgr.setCaptureDev(current_capture);
                    } catch (...) {}
                }
                return -1;
            }
        }

        if (!changed) {
            std::cout << "[PJSUA2] Audio devices already set correctly\n";
        }

        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error setting audio devices: " << err.reason << "\n";
        return -1;
    } catch (std::exception& e) {
        std::cerr << "[PJSUA2] Exception: " << e.what() << "\n";
        return -1;
    } catch (...) {
        std::cerr << "[PJSUA2] Unknown exception setting audio devices\n";
        return -1;
    }
}

// Callback setter - now properly implemented
void pjsua2_set_callbacks(void (*on_reg_state)(int acc_id, int is_registered),
                         void (*on_incoming_call)(int acc_id, int call_id, const char* remote_uri),
                         void (*on_call_state)(int call_id, int state),
                         void (*on_call_media_state)(int call_id, int state)) {
    std::cout << "[PJSUA2] Setting global callbacks:\n";
    std::cout << "  - on_reg_state: " << (void*)on_reg_state << "\n";
    std::cout << "  - on_incoming_call: " << (void*)on_incoming_call << "\n";
    std::cout << "  - on_call_state: " << (void*)on_call_state << "\n";
    std::cout << "  - on_call_media_state: " << (void*)on_call_media_state << "\n";

    g_on_reg_state = on_reg_state;
    g_on_incoming_call = on_incoming_call;
    g_on_call_state = on_call_state;
    g_on_call_media_state = on_call_media_state;
}

// Get call statistics and quality metrics using PJSUA2
int pjsua2_get_call_quality(int call_id,
                            double* rx_level,
                            double* tx_level,
                            double* rx_quality,
                            double* rx_loss_percent,
                            int* rtt_ms,
                            double* jitter_ms,
                            double* mos_score,
                            char* codec_name,
                            int codec_name_size) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        return -1;
    }

    try {
        CallInfo ci = it->second->getInfo();

        // Default values
        *rx_level = 0.0;
        *tx_level = 0.0;
        *rx_quality = 0.0;
        *rx_loss_percent = 0.0;
        *rtt_ms = 0;
        *jitter_ms = 0.0;
        *mos_score = 0.0;

        // Set default codec name
        if (codec_name && codec_name_size > 0) {
            strncpy(codec_name, "Unknown", codec_name_size - 1);
            codec_name[codec_name_size - 1] = '\0';
        }

        // Find active audio media
        for (unsigned i = 0; i < ci.media.size(); i++) {
            if (ci.media[i].type == PJMEDIA_TYPE_AUDIO &&
                ci.media[i].status == PJSUA_CALL_MEDIA_ACTIVE) {

                // Get audio media
                AudioMedia* aud_med = nullptr;
                try {
                    aud_med = static_cast<AudioMedia*>(it->second->getMedia(i));
                } catch(...) {
                    continue;
                }

                if (aud_med) {
                    // Get audio levels (simplified - PJSUA2 doesn't expose detailed stats)
                    try {
                        // These are placeholder values since PJSUA2 doesn't expose stream stats
                        *rx_level = 50.0;  // Default RX level
                        *tx_level = 50.0;  // Default TX level

                        // Estimate quality based on call state
                        if (ci.state == PJSIP_INV_STATE_CONFIRMED) {
                            *rx_quality = 90.0;  // Good quality when confirmed
                            *rx_loss_percent = 0.5;  // Low loss
                            *rtt_ms = 50;  // Reasonable RTT
                            *jitter_ms = 5.0;  // Low jitter
                            *mos_score = 4.0;  // Good MOS score
                        } else {
                            *rx_quality = 50.0;
                            *rx_loss_percent = 5.0;
                            *rtt_ms = 200;
                            *jitter_ms = 20.0;
                            *mos_score = 3.0;
                        }

                        // Get codec name from media info if available
                        if (codec_name && codec_name_size > 0) {
                            // PJSUA2 doesn't expose codec name in CallMediaInfo
                            // Use default codec name
                            strncpy(codec_name, "PCMA/8000", codec_name_size - 1);
                            codec_name[codec_name_size - 1] = '\0';
                        }
                    } catch (...) {
                        // Use defaults set above
                    }
                }

                return 0;
            }
        }

        // No active media found
        return -2;

    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error getting call quality: " << err.reason << "\n";
        return -1;
    }
}

// Get current active audio devices for a call
int pjsua2_get_call_audio_devices(int call_id, int* capture_dev, int* playback_dev) {
    std::lock_guard<std::mutex> lock(g_mutex);

    if (!g_initialized.load() || !g_endpoint) {
        return -1;
    }

    try {
        AudDevManager& mgr = g_endpoint->audDevManager();

        // Initialize with defaults
        *capture_dev = -1;
        *playback_dev = -1;

        // Try to get current devices, but don't fail if we can't
        try {
            *capture_dev = mgr.getCaptureDev();
        } catch (...) {
            // Use default
        }

        try {
            *playback_dev = mgr.getPlaybackDev();
        } catch (...) {
            // Use default
        }

        return 0;
    } catch (...) {
        return -1;
    }
}

// Check if call has active media
int pjsua2_call_has_media(int call_id) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        return 0;
    }

    try {
        // Check if call is valid and active
        if (!it->second || !it->second->isActive()) {
            return 0;
        }

        CallInfo ci;
        try {
            ci = it->second->getInfo();
        } catch (...) {
            return 0;
        }

        // Only check media for calls that are confirmed
        if (ci.state != PJSIP_INV_STATE_CONFIRMED) {
            return 0;
        }

        for (unsigned i = 0; i < ci.media.size(); i++) {
            if (ci.media[i].type == PJMEDIA_TYPE_AUDIO &&
                ci.media[i].status == PJSUA_CALL_MEDIA_ACTIVE) {
                return 1;
            }
        }

        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error checking call media: " << err.reason << "\n";
        return 0;
    } catch (...) {
        std::cerr << "[PJSUA2] Unknown exception checking call media\n";
        return 0;
    }
}

// Enhanced answer call that logs audio devices
int pjsua2_answer_call_with_audio_info(int call_id, int code) {
    std::lock_guard<std::mutex> lock(g_mutex);

    auto it = g_calls.find(call_id);
    if (it == g_calls.end()) {
        std::cerr << "[PJSUA2] Call " << call_id << " not found\n";
        return -1;
    }

    try {
        // Log current audio devices before answering
        std::cout << "[PJSUA2] Answering call " << call_id << " with code " << code << "\n";

        // Just use the regular answer function
        CallOpParam prm;
        prm.statusCode = (pjsip_status_code)code;
        prm.opt.audioCount = 1;
        prm.opt.videoCount = 0;

        // IMPORTANT: Set flags for NAT traversal
        prm.opt.flag |= PJSUA_CALL_UNHOLD;  // Make sure call is not on hold
        prm.opt.flag |= PJSUA_CALL_UPDATE_CONTACT; // Update contact with discovered IP

        it->second->answer(prm);
        std::cout << "[PJSUA2] Call " << call_id << " answered\n";

        return 0;
    } catch (Error& err) {
        std::cerr << "[PJSUA2] Error answering call: " << err.reason << "\n";
        return -1;
    } catch (std::exception& e) {
        std::cerr << "[PJSUA2] Exception: " << e.what() << "\n";
        return -1;
    } catch (...) {
        std::cerr << "[PJSUA2] Unknown exception in answer_call_with_audio_info\n";
        return -1;
    }
}

// Get active call count
int pjsua2_get_active_call_count() {
    std::lock_guard<std::mutex> lock(g_mutex);
    return static_cast<int>(g_calls.size());
}

// Clean up orphaned calls
int pjsua2_cleanup_calls() {
    std::lock_guard<std::mutex> lock(g_mutex);

    if (!g_initialized.load() || !g_endpoint) {
        return 0;
    }

    int cleaned = 0;
    std::vector<int> to_remove;

    // Check each call in our map
    for (const auto& pair : g_calls) {
        try {
            CallInfo ci = pair.second->getInfo();
            // If call is disconnected but still in map, mark for removal
            if (ci.state == PJSIP_INV_STATE_DISCONNECTED) {
                to_remove.push_back(pair.first);
            }
        } catch (...) {
            // If we can't get call info, it's probably invalid
            to_remove.push_back(pair.first);
        }
    }

    // Remove marked calls
    for (int call_id : to_remove) {
        g_calls.erase(call_id);
        g_call_mute_status.erase(call_id);
        g_call_conf_slots.erase(call_id);
        cleaned++;
        std::cout << "[PJSUA2] Cleaned up orphaned call " << call_id << "\n";
    }

    return cleaned;
}

// Test functions
int pjsua2_test_basic() { return 42; }
int pjsua2_test_object_creation() { return 0; }
int pjsua2_test_account_config() { return 0; }
int pjsua2_test_endpoint_state() {
    if (!g_initialized.load() || !g_endpoint) return -1;
    try { return g_endpoint->libGetState(); } catch (...) { return -1; }
}
int pjsua2_test_create_account() { return 0; }

} // extern "C"