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

function setStream({source, stream}) {
    if(streams[source] && streams[source].id !== stream.id) {
        streams[source].getTracks().forEach(track => track.stop())
    }

    streams[source] = stream
    m.redraw()

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

function reloadAllStreams() {
    State.online.forEach(username => {
        const rpc = connections[username]
        if(rpc) {
            rpc.getSenders().map(s => rpc.removeTrack(s))
        }
        signal({kind: 'rpc', value: {type: 'request'}, source: username})
    })
}

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 = ({streams: [stream]}) => {
        setStream({source: target, stream})
    }
    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 stream = streams[State.username]
    if(stream) {
        stream.getTracks().forEach(track => {
            try { rpc.addTrack(track, stream) }
            catch { }
        })
    }

    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]
    }
}

function destroyAll() {
    const people = new Set()
    const collect = [connections, datachannels, streams, screen]
        .map(collection => Object.keys(collection))
        .forEach(keys => keys.forEach(key => people.add(key)))
    people.forEach(destroyConnection)
}

addEventListener('stream', (e) => setStream(e.detail.value))
addEventListener('rpc', (e) => handlePeerInfo(e.detail))
addEventListener('join', (e) => createConnection(e.detail.value))
addEventListener('leave', (e) => destroyConnection(e.detail.value))
addEventListener('logout', () => destroyAll())
addEventListener('load', () => doNotLog.add('rpc'))