'use strict';

const startButton = document.getElementById('startButton');
const callButton = document.getElementById('callButton');
const hangupButton = document.getElementById('hangupButton');

var wssPort = 8081;
var webSocketConnection;

callButton.disabled = true;
hangupButton.disabled = true;

startButton.addEventListener('click', start);
callButton.addEventListener('click', call);
hangupButton.addEventListener('click', hangup);

let startTime;

const localVideo = document.getElementById('localVideo');
const remoteVideo = document.getElementById('remoteVideo');

localVideo.addEventListener('loadedmetadata', function() {
  console.log(`Szerokość lokalnego video videoWidth: ${this.videoWidth}px,  videoHeight: ${this.videoHeight}px`);
});

remoteVideo.addEventListener('loadedmetadata', function() {
  console.log(`Szerokość zdalnego video videoWidth: ${this.videoWidth}px,  videoHeight: ${this.videoHeight}px`);
});

remoteVideo.addEventListener('resize', () => {
  console.log(`Rozmiar zdalnego video zmieniony na: ${remoteVideo.videoWidth}x${remoteVideo.videoHeight}`);

  if (startTime) {
    const elapsedTime = window.performance.now() - startTime;
    console.log('Czas ustanowienia połączenia: ' + elapsedTime.toFixed(3) + 'ms');
    startTime = null;
  }
});

let localStream;
let pc1;
let pc2;
const offerOptions = {
  offerToReceiveAudio: 1,
  offerToReceiveVideo: 1
};

// ustawienia parametrów strumienia dla funkcji getUserMedia

const mediaConstraints = {
  audio: true, video: true
}

// ---------------------------------------------------------

function getName(pc) {
  return (pc === pc1) ? 'pc1' : 'pc2';
}

function getOtherPc(pc) {
  return (pc === pc1) ? pc2 : pc1;
}

async function start() {

  // zainicjowanie połączenia z serwerem WebSocket

  webSocketConnection = new WebSocket('ws://127.0.0.1' + ':' + wssPort);

  webSocketConnection.onopen = onOpenConnection;
  webSocketConnection.onmessage = onReceivedMessage;
  webSocketConnection.onclose = onCloseConnection;

  // ---------------------------------------------


  startButton.disabled = true;

  console.log('Generowanie żądania lokalnego strumienia');

  try {

    // Zad 3.2.3. przechwyć strumień mediów a następnie przypisz go do obiektu localVideo
      // UWAGA - konieczne jest również przypisanie pobranego strumienia do obiektu localStream
    // --------------------------------------------------------------------------
    const stream = await navigator.mediaDevices.getUserMedia(mediaConstraints)
    localVideo.srcObject = stream;
    localStream = stream;
    callButton.disabled = false;

  } catch (e) {
    alert(`getUserMedia() error: ${e.name}`);
  }
}





function getSelectedSdpSemantics() {

  return {sdpSemantics: 'unified-plan'};
}





// funkcja inicjująca połączenie z drugim użytkownikiem

async function call() {

  callButton.disabled = true;
  hangupButton.disabled = false;

  console.log('Rozpoczęcie połączenia');
  startTime = window.performance.now();



  // pobranie poszczególnych części strumienia mediów
  const videoTracks = localStream.getVideoTracks();
  const audioTracks = localStream.getAudioTracks();



  if (videoTracks.length > 0) {
    console.log(`Używam urządzenia video: ${videoTracks[0].label}`);
  }

  if (audioTracks.length > 0) {
    console.log(`Używam urządznia audio: ${audioTracks[0].label}`);
  }

  const configuration = getSelectedSdpSemantics();
  console.log('RTCPeerConnection configuration:', configuration);

  pc1 = new RTCPeerConnection(configuration);
  console.log('Stworzono lokalne połączenie PEER dla obiektu pc1');

  pc1.addEventListener('icecandidate', e => onIceCandidate(pc1, e));

  pc2 = new RTCPeerConnection(configuration);
  console.log('Stworzono zdalne połaczenie PEER dla obiektu pc2');

  pc2.addEventListener('icecandidate', e => onIceCandidate(pc2, e));
  pc1.addEventListener('iceconnectionstatechange', e => onIceStateChange(pc1, e));

  pc2.addEventListener('iceconnectionstatechange', e => onIceStateChange(pc2, e));
  pc2.addEventListener('track', gotRemoteStream);

  // stworzenie lokalnego strumienia dla połączenia peer-to-peer
  // to właśnie ten strumień chcemy przekazywać drugiemy użytkownikowi
  localStream.getTracks().forEach(track => pc1.addTrack(track, localStream));
  console.log('Added local stream to pc1');

  try {
    console.log('pc1 createOffer start');
    const offer = await pc1.createOffer(offerOptions);
    await onCreateOfferSuccess(offer);
  } catch (e) {
    onCreateSessionDescriptionError(e);
  }
}




function onCreateSessionDescriptionError(error) {
  console.log(`Nie udało się utworzyć deskryptora sesji: ${error.toString()}`);
}




async function onCreateOfferSuccess(desc) {

  console.log(`Oferta od pc1\n${desc.sdp}`);
  console.log('pc1 setLocalDescription start');

  try {
    await pc1.setLocalDescription(desc);
    onSetLocalSuccess(pc1);
  } catch (e) {
    onSetSessionDescriptionError();
  }

  console.log('pc2 setRemoteDescription start');
  try {
    await pc2.setRemoteDescription(desc);
    onSetRemoteSuccess(pc2);
  } catch (e) {
    onSetSessionDescriptionError();
  }

  console.log('pc2 createAnswer start');


  try {

    const answer = await pc2.createAnswer();
    await onCreateAnswerSuccess(answer);

  } catch (e) {

    onCreateSessionDescriptionError(e);

  }
}


function onSetLocalSuccess(pc) {
  console.log(`${getName(pc)} setLocalDescription complete`);
}


function onSetRemoteSuccess(pc) {
  console.log(`${getName(pc)} setRemoteDescription complete`);
}


function onSetSessionDescriptionError(error) {
  console.log(`Nie udało się utowrzyć deskryptora sesji: ${error.toString()}`);
}


function gotRemoteStream(e) {

  // Zad. 3.2.4 przechwytywanie zdalnego strumienia i wyświetlenie go w obiekcie remoteVideo
  // należy również sprawdzić czy obiekt remoteVideo nie ma już przypisanego danego strumienia
  if (remoteVideo.srcObject !== e.streams[0]) {
    remoteVideo.srcObject = e.streams[0];
  }
}



async function onCreateAnswerSuccess(desc) {
  console.log(`Odpowiedź od pc2:\n${desc.sdp}`);
  console.log('pc2 setLocalDescription start');
  try {
    await pc2.setLocalDescription(desc);
    onSetLocalSuccess(pc2);
  } catch (e) {
    onSetSessionDescriptionError(e);
  }
  console.log('pc1 setRemoteDescription start');
  try {
    await pc1.setRemoteDescription(desc);
    onSetRemoteSuccess(pc1);
  } catch (e) {
    onSetSessionDescriptionError(e);
  }
}


async function onIceCandidate(pc, event) {
  try {
    await (getOtherPc(pc).addIceCandidate(event.candidate));
    onAddIceCandidateSuccess(pc);
  } catch (e) {
    onAddIceCandidateError(pc, e);
  }
  console.log(`${getName(pc)} ICE candidate:\n${event.candidate ? event.candidate.candidate : '(null)'}`);
}



function onAddIceCandidateSuccess(pc) {
  console.log(`${getName(pc)} addIceCandidate success`);
}


function onAddIceCandidateError(pc, error) {
  console.log(`${getName(pc)} failed to add ICE Candidate: ${error.toString()}`);
}

function onIceStateChange(pc, event) {
  if (pc) {
    console.log(`${getName(pc)} ICE state: ${pc.iceConnectionState}`);
    console.log('ICE zdarzenie zmiany statusu: ', event);
  }
}


function hangup() {
  console.log('Zakończenie połączenia');
  pc1.close();
  pc2.close();
  pc1 = null;
  pc2 = null;
  hangupButton.disabled = true;
  callButton.disabled = false;
}


// Funkcje WebSocket

function onOpenConnection() {

  // Zad 3.2.1
  var readyState = webSocketConnection.readyState;
  var span = document.getElementById(wss-status-txt);
  if(readyState == 1){
    span.textContent = "Połączono";
  }
  console.log('Ustanowiono połączenie z serwerem WebSocket');
}

function onCloseConnection() {

  // Zad 3.2.1
  var readyState = webSocketConnection.readyState;
  var span = document.getElementById("wss-status-txt");
  span.innerText = readyState;
  if(readyState == 3){
    span.textContent = "Połączono";
  }
  console.log('Zamknięto połączenie z serwerem WebSocket');
}

function onReceivedMessage(message) {
  if (!peerConnection) startTransmission(false);
  var signal = JSON.parse(message.data);
  if (signal.sdp) {
      peerConnection.setRemoteDescription(new RTCSessionDescription(signal.sdp), function () {
          peerConnection.createAnswer(onDescriptionReady, errorHandler);
      }, errorHandler);
  } else if (signal.ice) {
      peerConnection.addIceCandidate(new RTCIceCandidate(signal.ice));
  }
}