const connections = {}
const datachannels = {}
const streams = {}
const screen = {}

function setTracks({source, tracks}) {
    streams[source] = streams[source] || new MediaStream()
    streams[source].getTracks().forEach(t => streams[source].removeTrack(t))
    tracks.forEach(track => streams[source].addTrack(track))
    m.redraw()

    if(source === State.username) {
        reloadAllStreams()
    }
}

function reloadAllStreams() {
    State.online.forEach(username => {
        signal({kind: 'rpc', value: {type: 'request'}, source: username})
    })
}

function getOwnTracks() {
    if(streams[State.username]) {
        return streams[State.username].getTracks()
    }
    else {
        return []
    }
}

function createConnection(target) {
    const rpc = new RTCPeerConnection(rpcConfig)

    rpc.onicecandidate = ({candidate}) => {
        if(candidate && candidate.candidate) {
            const value = {type: 'candidate', candidate}
            wire({kind: 'rpc', value, target})
        }
    }
    rpc.ontrack = () => {
        const tracks = rpc.getReceivers().map(t => t.track)
        setTracks({source: target, tracks: tracks})
    }
    rpc.onconnectionstatechange = () => {
        if(rpc.connectionState === 'failed') {
            console.log(target, 'failed, retry!')
            wire({kind: 'rpc', value: {type: 'request'}, target})
        }
    }
    rpc.ondatachannel = ({channel}) => {
        datachannels[target] = channel
        datachannels[target].onmessage = ({data}) => console.log(data)

        // for testing purposes
        const msg = `rpc established from ${target} to ${State.username}`
        datachannels[target].send(msg)
        console.log(msg)
    }

    connections[target] = rpc
    if(State.username > target) {
        datachannels[target] = rpc.createDataChannel('test')
        datachannels[target].onmessage = ({data}) => console.log(data)
        signal({kind: 'rpc', value: {type: 'request'}, source: target})
    }
}

async function handlePeerInfo({source: target, value}) {
    const rpc = connections[target]

    if(!rpc) {
        return
    }

    const olds = rpc.getSenders().map(t => t.track)
    const news = getOwnTracks()
    rpc.getSenders().filter(s => !news.includes(s.track)).forEach(s => rpc.removeTrack(s))
    news.filter(track => !olds.includes(track)).forEach(t => t && rpc.addTrack(t))

    if(value.type === 'request') {
        const localOffer = await rpc.createOffer()
        await rpc.setLocalDescription(localOffer)
        wire({kind: 'rpc', value: localOffer, target})
    }
    else if(value.type === 'offer') {
        const remoteOffer = new RTCSessionDescription(value)
        await rpc.setRemoteDescription(remoteOffer)
        const localAnswer = await rpc.createAnswer()
        await rpc.setLocalDescription(localAnswer)
        wire({kind: 'rpc', value: localAnswer, target})
    }
    else if(value.type === 'answer') {
        const remoteAnswer = new RTCSessionDescription(value)
        await rpc.setRemoteDescription(remoteAnswer).catch(e => e)
    }
    else if(value.type === 'candidate') {
        const candidate = new RTCIceCandidate(value.candidate)
        await rpc.addIceCandidate(candidate).catch(e => e)
    }
}

function destroyConnection(username) {
    if(streams[username]) {
        streams[username].getTracks().forEach(t => t.stop())
        delete streams[username]
    }
    if(datachannels[username]) {
        datachannels[username].close()
        delete datachannels[username]
    }
    if(connections[username]) {
        connections[username].getReceivers().forEach(r => r.track.stop())
        connections[username].close()
        delete connections[username]
    }
}

addEventListener('tracks', (e) => setTracks(e.detail.value))
addEventListener('rpc', (e) => handlePeerInfo(e.detail))
addEventListener('join', (e) => createConnection(e.detail.value))
addEventListener('leave', (e) => destroyConnection(e.detail.value))
addEventListener('load', () => doNotLog.add('rpc'))