исправь звонок не работает  , я захажу в чат нажимаю на челоека позвонить но звонок не происходит
<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title>Децентрализованный P2P Чат</title>
    <style>
        /* Основные стили */
        * {
            box-sizing: border-box;
            margin: 0;
            padding: 0;
        }

        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #c3ec52, #0ba29d);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }

        .chat-container {
            background-color: #ffffff;
            width: 100%;
            max-width: 900px;
            height: 90vh;
            border-radius: 12px;
            box-shadow: 0 8px 16px rgba(0,0,0,0.2);
            display: flex;
            flex-direction: column;
            overflow: hidden;
        }

        header {
            background-color: #4CAF50;
            color: white;
            padding: 20px;
            text-align: center;
            position: relative;
        }

        header h1 {
            font-size: 1.8rem;
        }

        .peer-id {
            font-size: 0.9rem;
            margin-top: 5px;
            opacity: 0.8;
            word-wrap: break-word;
        }

        .main {
            flex: 1;
            display: flex;
            overflow: hidden;
        }

        .sidebar {
            width: 250px;
            background-color: #f4f4f4;
            border-right: 1px solid #ddd;
            padding: 20px;
            display: flex;
            flex-direction: column;
        }

        .sidebar-section {
            margin-bottom: 30px;
        }

        .sidebar label {
            display: block;
            margin-bottom: 8px;
            font-weight: bold;
            color: #333;
        }

        .sidebar input[type="text"] {
            width: 100%;
            padding: 10px;
            border: 1px solid #ccc;
            border-radius: 6px;
            margin-bottom: 10px;
            transition: border-color 0.3s;
        }

        .sidebar input[type="text"]:focus {
            border-color: #4CAF50;
            outline: none;
        }

        .sidebar button {
            width: 100%;
            padding: 10px;
            background-color: #4CAF50;
            border: none;
            border-radius: 6px;
            color: white;
            font-weight: bold;
            cursor: pointer;
            transition: background-color 0.3s;
        }

        .sidebar button:hover {
            background-color: #45a049;
        }

        .online-section h3 {
            margin-bottom: 10px;
            color: #333;
        }

        #online-users {
            list-style: none;
            max-height: 300px;
            overflow-y: auto;
        }

        #online-users li {
            display: flex;
            justify-content: space-between;
            align-items: center;
            padding: 8px 10px;
            border-bottom: 1px solid #ddd;
            border-radius: 6px;
            margin-bottom: 5px;
            background-color: #fff;
            transition: background-color 0.3s;
            cursor: pointer; /* Сделать пункт списка кликабельным */
        }

        #online-users li:hover {
            background-color: #f1f1f1;
        }

        #online-users li.active {
            background-color: #d1e7dd; /* Цвет для активного пользователя */
        }

        .user-info {
            display: flex;
            align-items: center;
            flex: 1;
        }

        .user-info .status {
            width: 10px;
            height: 10px;
            border-radius: 50%;
            background-color: #4CAF50;
            margin-right: 10px;
        }

        .user-info .user-id {
            font-size: 0.9rem;
            color: #333;
            overflow: hidden;
            text-overflow: ellipsis;
            white-space: nowrap;
            max-width: 140px;
        }

        .user-actions button {
            padding: 5px 10px;
            background-color: #2196F3;
            border: none;
            border-radius: 4px;
            color: white;
            cursor: pointer;
            font-size: 0.8rem;
            transition: background-color 0.3s;
        }

        .user-actions button:hover {
            background-color: #1976D2;
        }

        .chat-section {
            flex: 1;
            display: flex;
            flex-direction: column;
            padding: 20px;
            background-color: #fafafa;
            position: relative;
        }

        #active-peer {
            margin-bottom: 10px;
            font-weight: bold;
            color: #333;
        }

        #messages {
            flex: 1;
            overflow-y: auto;
            padding-right: 10px;
            margin-bottom: 10px;
        }

        .message {
            margin-bottom: 15px;
            max-width: 70%;
            padding: 10px 15px;
            border-radius: 20px;
            position: relative;
            word-wrap: break-word;
            box-shadow: 0 2px 5px rgba(0,0,0,0.1);
        }

        .message.self {
            background-color: #DCF8C6;
            align-self: flex-end;
            border-bottom-right-radius: 0;
        }

        .message.other {
            background-color: #FFFFFF;
            border: 1px solid #ddd;
            align-self: flex-start;
            border-bottom-left-radius: 0;
        }

        .message.system {
            background-color: #e0e0e0;
            text-align: center;
            max-width: 100%;
            margin: 10px auto;
            border-radius: 10px;
            padding: 8px 12px;
            font-style: italic;
            color: #555;
        }

        .input-section, .file-section {
            display: flex;
            align-items: center;
            margin-top: 10px;
        }

        .input-section input[type="text"],
        .file-section input[type="file"] {
            flex: 1;
            padding: 10px;
            border: 1px solid #ccc;
            border-radius: 6px;
            margin-right: 10px;
            transition: border-color 0.3s;
        }

        .input-section input[type="text"]:focus,
        .file-section input[type="file"]:focus {
            border-color: #4CAF50;
            outline: none;
        }

        .input-section button,
        .file-section button {
            padding: 10px 15px;
            background-color: #4CAF50;
            border: none;
            border-radius: 6px;
            color: white;
            font-weight: bold;
            cursor: pointer;
            transition: background-color 0.3s;
        }

        .input-section button:hover,
        .file-section button:hover {
            background-color: #45a049;
        }

        #call-btn {
            margin-top: 15px;
            background-color: #2196F3;
            color: white;
        }

        #call-btn:hover {
            background-color: #1976D2;
        }

        /* Окно звонка */
        .call-window {
            position: fixed;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            background-color: #ffffff;
            padding: 30px;
            border: 2px solid #4CAF50;
            border-radius: 12px;
            box-shadow: 0 8px 16px rgba(0,0,0,0.3);
            display: none;
            z-index: 1000;
            width: 300px;
            text-align: center;
        }

        .call-window.active {
            display: block;
        }

        .call-window p {
            margin-bottom: 20px;
            font-size: 1rem;
            color: #333;
        }

        .call-window button {
            padding: 10px 20px;
            border: none;
            border-radius: 6px;
            cursor: pointer;
            font-weight: bold;
            transition: background-color 0.3s;
            margin: 0 10px;
        }

        .call-window #accept-call-btn {
            background-color: #4CAF50;
            color: white;
        }

        .call-window #accept-call-btn:hover {
            background-color: #45a049;
        }

        .call-window #reject-call-btn {
            background-color: #f44336;
            color: white;
        }

        .call-window #reject-call-btn:hover {
            background-color: #d32f2f;
        }

        /* Аудио элемент */
        .audio-chat {
            margin-top: 10px;
        }

        /* Медиа запросы для адаптивности */
        @media (max-width: 768px) {
            .main {
                flex-direction: column;
            }

            .sidebar {
                width: 100%;
                border-right: none;
                border-bottom: 1px solid #ddd;
            }

            .chat-section {
                padding: 15px;
            }

            .input-section, .file-section {
                flex-direction: column;
            }

            .input-section input[type="text"],
            .file-section input[type="file"] {
                margin-right: 0;
                margin-bottom: 10px;
                width: 100%;
            }

            .input-section button,
            .file-section button {
                width: 100%;
            }
        }
    </style>
</head>
<body>
    <div class="chat-container">
        <header>
            <h1>Децентрализованный P2P Чат</h1>
            <p class="peer-id">Ваш Peer ID: <span id="peer-id">Подключение...</span></p>
        </header>
        <div class="main">
            <div class="sidebar">
                <div class="sidebar-section connect-section">
                    <label for="remote-id">Подключиться к Peer ID:</label>
                    <input type="text" id="remote-id" placeholder="Введите Peer ID другого пользователя">
                    <button id="connect-btn">Подключиться</button>
                </div>
                <div class="sidebar-section online-section">
                    <h3>Онлайн пользователи:</h3>
                    <ul id="online-users">
                        <!-- Список онлайн пользователей -->
                    </ul>
                </div>
            </div>
            <div class="chat-section">
                <div id="active-peer">Нет активного чата</div>
                <div id="messages"></div>
                <div class="input-section">
                    <input type="text" id="message-input" placeholder="Введите сообщение">
                    <button id="send-btn">Отправить</button>
                </div>
                <div class="file-section">
                    <input type="file" id="file-input">
                    <button id="send-file-btn">Отправить файл</button>
                </div>
                <button id="call-btn">Позвонить</button>
            </div>
        </div>
    </div>

    <!-- Окно звонка -->
    <div class="call-window" id="call-window">
        <p id="call-status">Входящий звонок от <span id="caller-id"></span></p>
        <button id="accept-call-btn">Принять</button>
        <button id="reject-call-btn">Отклонить</button>
    </div>

    <!-- Подключение PeerJS через CDN -->
    <script src="https://unpkg.com/peerjs@1.4.7/dist/peerjs.min.js"></script>
    <script>
        class P2PChat {
            constructor() {
                this.peer = null;
                this.connections = new Map();
                this.currentCall = null;
                this.localStream = null;
                this.activePeerId = null; // Активный Peer ID для чата

                // Элементы интерфейса
                this.peerIdDisplay = document.getElementById('peer-id');
                this.connectBtn = document.getElementById('connect-btn');
                this.remoteIdInput = document.getElementById('remote-id');
                this.messagesArea = document.getElementById('messages');
                this.sendBtn = document.getElementById('send-btn');
                this.messageInput = document.getElementById('message-input');
                this.onlineUsersList = document.getElementById('online-users');
                this.fileInput = document.getElementById('file-input');
                this.sendFileBtn = document.getElementById('send-file-btn');
                this.callBtn = document.getElementById('call-btn');
                this.activePeerDisplay = document.getElementById('active-peer');

                // Элементы окна звонка
                this.callWindow = document.getElementById('call-window');
                this.callerIdSpan = document.getElementById('caller-id');
                this.acceptCallBtn = document.getElementById('accept-call-btn');
                this.rejectCallBtn = document.getElementById('reject-call-btn');

                this.initPeer();
                this.bindEvents();
            }

            initPeer() {
                this.peer = new Peer();

                this.peer.on('open', (id) => {
                    this.peerIdDisplay.textContent = id;
                    this.addOnlineUser(id, true); // Добавить себя в список онлайн пользователей
                });

                this.peer.on('connection', (conn) => this.handleConnection(conn));

                this.peer.on('call', (call) => this.handleIncomingCall(call));

                this.peer.on('error', (err) => {
                    console.error(err);
                    alert('Произошла ошибка: ' + err);
                });
            }

            bindEvents() {
                this.connectBtn.addEventListener('click', () => this.connectToPeer());
                this.sendBtn.addEventListener('click', () => this.sendMessage());
                this.messageInput.addEventListener('keypress', (e) => {
                    if (e.key === 'Enter') this.sendMessage();
                });
                this.sendFileBtn.addEventListener('click', () => this.sendFile());
                this.callBtn.addEventListener('click', () => this.initiateCall());

                // Обработчики для окна звонка
                this.acceptCallBtn.addEventListener('click', () => this.acceptCall());
                this.rejectCallBtn.addEventListener('click', () => this.rejectCall());

                // Обработчик клика по пользователю для выбора активного чата
                this.onlineUsersList.addEventListener('click', (e) => {
                    const li = e.target.closest('li');
                    if (li && !li.classList.contains('active')) {
                        this.selectActivePeer(li);
                    }
                });
            }

            connectToPeer() {
                const remoteId = this.remoteIdInput.value.trim();
                if (!remoteId) {
                    alert('Введите Peer ID для подключения.');
                    return;
                }

                if (this.connections.has(remoteId)) {
                    alert('Уже подключены к этому Peer.');
                    return;
                }

                const conn = this.peer.connect(remoteId);

                conn.on('open', () => {
                    this.setupConnection(conn);
                    this.addOnlineUser(remoteId);
                    this.appendSystemMessage(`Соединение с ${remoteId} установлено.`);
                    if (!this.activePeerId) {
                        this.setActivePeer(remoteId);
                    }
                });

                conn.on('error', (err) => {
                    console.error(`Ошибка соединения с ${remoteId}:`, err);
                    this.appendSystemMessage(`Ошибка соединения с ${remoteId}: ${err}`);
                });

                conn.on('close', () => {
                    this.appendSystemMessage(`Соединение с ${remoteId} закрыто.`);
                    this.removeOnlineUser(remoteId);
                    this.connections.delete(remoteId);
                    if (this.activePeerId === remoteId) {
                        this.activePeerId = null;
                        this.activePeerDisplay.textContent = 'Нет активного чата';
                    }
                });
            }

            handleConnection(conn) {
                if (this.connections.has(conn.peer)) {
                    console.warn(`Уже есть соединение с ${conn.peer}`);
                    conn.close();
                    return;
                }

                this.setupConnection(conn);
                this.addOnlineUser(conn.peer);
                this.appendSystemMessage(`Peer ${conn.peer} подключился.`);
                if (!this.activePeerId) {
                    this.setActivePeer(conn.peer);
                }
            }

            setupConnection(conn) {
                this.connections.set(conn.peer, conn);

                conn.on('data', (data) => this.handleIncomingData(data, conn.peer));

                conn.on('close', () => {
                    this.appendSystemMessage(`Соединение с ${conn.peer} закрыто.`);
                    this.removeOnlineUser(conn.peer);
                    this.connections.delete(conn.peer);
                    if (this.activePeerId === conn.peer) {
                        this.activePeerId = null;
                        this.activePeerDisplay.textContent = 'Нет активного чата';
                    }
                });
            }

            handleIncomingData(data, peerId) {
                try {
                    const parsedData = JSON.parse(data);
                    switch (parsedData.type) {
                        case 'message':
                            this.displayMessage(parsedData.content, 'other');
                            break;
                        case 'file':
                            this.receiveFile(parsedData, peerId);
                            break;
                        default:
                            console.warn('Неизвестный тип сообщения:', parsedData.type);
                    }
                } catch (error) {
                    console.error('Ошибка разбора данных:', error);
                    this.appendSystemMessage(`Получены некорректные данные от ${peerId}.`);
                }
            }

            sendMessage() {
                const message = this.messageInput.value.trim();
                if (!message) return;

                if (!this.activePeerId) {
                    alert('Выберите пользователя для отправки сообщения.');
                    return;
                }

                const conn = this.connections.get(this.activePeerId);
                if (!conn || conn.open === false) {
                    alert('Нет открытого соединения для отправки сообщения.');
                    return;
                }

                const data = JSON.stringify({ type: 'message', content: message });

                try {
                    conn.send(data);
                    this.displayMessage(message, 'self');
                    this.messageInput.value = '';
                } catch (err) {
                    console.error('Ошибка отправки сообщения:', err);
                    this.appendSystemMessage(`Не удалось отправить сообщение пользователю ${this.activePeerId}.`);
                }
            }

            displayMessage(message, type) {
                const messageDiv = document.createElement('div');
                messageDiv.classList.add('message', type);
                messageDiv.textContent = message;

                this.messagesArea.appendChild(messageDiv);
                this.scrollToBottom();
            }

            appendSystemMessage(message) {
                const messageDiv = document.createElement('div');
                messageDiv.classList.add('message', 'system');
                messageDiv.textContent = message;

                this.messagesArea.appendChild(messageDiv);
                this.scrollToBottom();
            }

            addOnlineUser(userId, isSelf = false) {
                if ([...this.onlineUsersList.children].some(li => li.querySelector('.user-id').textContent === userId)) {
                    return;
                }

                const li = document.createElement('li');

                const userInfo = document.createElement('div');
                userInfo.classList.add('user-info');

                const status = document.createElement('span');
                status.classList.add('status');
                status.style.backgroundColor = isSelf ? '#4CAF50' : '#4CAF50';

                const userIdSpan = document.createElement('span');
                userIdSpan.classList.add('user-id');
                userIdSpan.textContent = userId;

                userInfo.appendChild(status);
                userInfo.appendChild(userIdSpan);

                li.appendChild(userInfo);

                if (!isSelf) {
                    const userActions = document.createElement('div');
                    userActions.classList.add('user-actions');

                    const callButton = document.createElement('button');
                    callButton.textContent = 'Позвонить';
                    callButton.onclick = (e) => {
                        e.stopPropagation(); // Предотвращает выбор пользователя при нажатии кнопки
                        this.initiateCall(userId);
                    };

                    userActions.appendChild(callButton);
                    li.appendChild(userActions);
                }

                this.onlineUsersList.appendChild(li);
                if (!isSelf) {
                    this.appendSystemMessage(`${userId} подключился.`);
                }
            }

            removeOnlineUser(userId) {
                [...this.onlineUsersList.children].forEach(li => {
                    if (li.querySelector('.user-id').textContent === userId) {
                        this.onlineUsersList.removeChild(li);
                        this.appendSystemMessage(`${userId} отключился.`);
                    }
                });
            }

            setActivePeer(peerId) {
                // Снять выделение с текущего активного пользователя
                [...this.onlineUsersList.children].forEach(li => {
                    if (li.classList.contains('active')) {
                        li.classList.remove('active');
                    }
                });

                // Выбрать нового активного пользователя
                const targetLi = [...this.onlineUsersList.children].find(li => li.querySelector('.user-id').textContent === peerId);
                if (targetLi) {
                    targetLi.classList.add('active');
                    this.activePeerId = peerId;
                    this.activePeerDisplay.textContent = `Активный чат с: ${peerId}`;
                    this.clearMessages();
                }
            }

            selectActivePeer(li) {
                const peerId = li.querySelector('.user-id').textContent;
                this.setActivePeer(peerId);
            }

            clearMessages() {
                this.messagesArea.innerHTML = '';
            }

            sendFile() {
                const file = this.fileInput.files[0];
                if (!file) {
                    alert('Пожалуйста, выберите файл для отправки.');
                    return;
                }

                if (!this.activePeerId) {
                    alert('Выберите пользователя для отправки файла.');
                    return;
                }

                const conn = this.connections.get(this.activePeerId);
                if (!conn || conn.open === false) {
                    alert('Нет открытого соединения для отправки файла.');
                    return;
                }

                const reader = new FileReader();
                reader.onload = () => {
                    const arrayBuffer = reader.result;
                    const uint8Array = Array.from(new Uint8Array(arrayBuffer));

                    const data = JSON.stringify({
                        type: 'file',
                        content: uint8Array,
                        fileName: file.name,
                        fileType: file.type
                    });

                    try {
                        conn.send(data);
                        this.appendSystemMessage(`Вы отправили файл: ${file.name} пользователю ${this.activePeerId}.`);
                        this.fileInput.value = '';
                    } catch (err) {
                        console.error('Ошибка отправки файла:', err);
                        this.appendSystemMessage(`Не удалось отправить файл пользователю ${this.activePeerId}.`);
                    }
                };

                reader.onerror = (error) => {
                    console.error('Ошибка чтения файла:', error);
                    alert('Не удалось прочитать файл.');
                };

                reader.readAsArrayBuffer(file);
            }

            receiveFile(data, peerId) {
                const { content, fileName, fileType } = data;

                if (!content || !fileName || !fileType) {
                    console.error('Получены неполные данные файла:', data);
                    this.appendSystemMessage(`Получены некорректные данные файла от ${peerId}.`);
                    return;
                }

                try {
                    const uint8Array = new Uint8Array(content);
                    const blob = new Blob([uint8Array], { type: fileType });

                    const link = document.createElement('a');
                    const url = URL.createObjectURL(blob);
                    link.href = url;
                    link.download = fileName;
                    link.textContent = `Скачать файл: ${fileName}`;
                    link.className = 'file-link';
                    link.style.color = '#0066cc';
                    link.style.textDecoration = 'none';
                    link.style.display = 'block';
                    link.style.marginTop = '5px';
                    link.target = '_blank';

                    const fileMessage = document.createElement('div');
                    fileMessage.classList.add('message', 'other');
                    fileMessage.innerHTML = `Друг отправил файл: ${fileName}`;
                    fileMessage.appendChild(link);

                    this.messagesArea.appendChild(fileMessage);
                    this.scrollToBottom();
                } catch (err) {
                    console.error('Ошибка обработки полученного файла:', err);
                    this.appendSystemMessage(`Не удалось обработать файл от ${peerId}.`);
                }
            }

            initiateCall(peerId) {
                navigator.mediaDevices.getUserMedia({ audio: true, video: false })
                    .then(stream => {
                        this.localStream = stream;
                        const call = this.peer.call(peerId, stream);
                        this.setupCall(call);
                        this.appendSystemMessage(`Вы позвонили ${peerId}.`);
                    })
                    .catch(err => {
                        console.error('Ошибка доступа к микрофону:', err);
                        alert('Не удалось получить доступ к микрофону.');
                    });
            }

            handleIncomingCall(call) {
                this.callWindow.classList.add('active');
                this.callerIdSpan.textContent = call.peer;

                this.acceptCallBtn.onclick = () => {
                    navigator.mediaDevices.getUserMedia({ audio: true, video: false })
                        .then(stream => {
                            this.localStream = stream;
                            call.answer(stream);
                            this.setupCall(call);
                            this.callWindow.classList.remove('active');
                            this.appendSystemMessage(`Вы приняли звонок от ${call.peer}.`);
                        })
                        .catch(err => {
                            console.error('Ошибка доступа к микрофону:', err);
                            alert('Не удалось получить доступ к микрофону.');
                        });
                };

                this.rejectCallBtn.onclick = () => {
                    call.close();
                    this.callWindow.classList.remove('active');
                    this.appendSystemMessage(`Вы отклонили звонок от ${call.peer}.`);
                };
            }

            setupCall(call) {
                if (this.currentCall) {
                    this.currentCall.close();
                }
                this.currentCall = call;

                call.on('stream', (remoteStream) => {
                    const audio = document.createElement('audio');
                    audio.srcObject = remoteStream;
                    audio.autoplay = true;
                    audio.controls = true;
                    audio.classList.add('audio-chat');
                    this.messagesArea.appendChild(audio);
                    this.scrollToBottom();
                });

                call.on('close', () => {
                    this.appendSystemMessage('Звонок завершен.');
                });

                call.on('error', (err) => {
                    console.error('Ошибка звонка:', err);
                    this.appendSystemMessage('Произошла ошибка во время звонка.');
                });
            }

            acceptCall() {
                // Логика принятия звонка уже реализована в handleIncomingCall
            }

            rejectCall() {
                // Логика отклонения звонка уже реализована в handleIncomingCall
            }

            sendFileUpdate() {
                // Удален, не используется
            }

            initiateCallButtonHandler() {
                // Удален, не используется
            }

            initiateCall() {
                const remoteId = this.remoteIdInput.value.trim();

                if (!remoteId) {
                    alert('Введите Peer ID для звонка.');
                    return;
                }

                if (remoteId === this.peer.id) {
                    alert('Вы не можете звонить себе.');
                    return;
                }

                this.initiateCall(remoteId);
            }

            scrollToBottom() {
                this.messagesArea.scrollTop = this.messagesArea.scrollHeight;
            }
        }

        document.addEventListener('DOMContentLoaded', () => {
            new P2PChat();
        });
    </script>
</body>
</html>