import express from 'express'
const app = express()

import https from 'httpolyglot'
import fs from 'fs'
import path from 'path'
const __dirname = path.resolve()

// import { Server } from 'socket.io'
import Server from 'socket.io'
import mediasoup from 'mediasoup'

app.get('/', (req, res) => {
  res.send('Hello from mediasoup app!')
})

app.use('/sfu', express.static(path.join(__dirname, 'public')))

// SSL cert for HTTPS access
const options = {
  key: fs.readFileSync('./server/ssl/key.pem', 'utf-8'),
  cert: fs.readFileSync('./server/ssl/cert.pem', 'utf-8')
}

const httpsServer = https.createServer(options, app)
httpsServer.listen(3000, () => {
  console.log('listening on port: ' + 3000)
})

// const io = new Server(httpsServer)
const io = new Server(httpsServer)

const peers = io.of('/mediasoup')

/**
 * Worker
 * |-> Router(s)
 *     |-> Producer Transport(s)
 *         |-> Producer
 *     |-> Consumer Transport(s)
 *         |-> Consumer 
 **/
 let worker
 let routers = {}
 let producerTransport
 let consumerTransport
 let producer
 let consumer

const createWorker = async () => {
  worker = await mediasoup.createWorker({
    rtcMinPort: 2000,
    rtcMaxPort: 2020,
  })
  console.log(`worker pid ${worker.pid}`)

  worker.on('died', error => {
    // This implies something serious happened, so kill the application
    console.error('mediasoup worker has died')
    setTimeout(() => process.exit(1), 2000) // exit in 2 seconds
  })

  return worker
}

// We create a Worker as soon as our application starts
worker = createWorker()

// This is an Array of RtpCapabilities
// https://mediasoup.org/documentation/v3/mediasoup/rtp-parameters-and-capabilities/#RtpCodecCapability
// list of media codecs supported by mediasoup ...
// https://github.com/versatica/mediasoup/blob/v3/src/supportedRtpCapabilities.ts
const mediaCodecs = [
  {
    kind: 'audio',
    mimeType: 'audio/opus',
    clockRate: 48000,
    channels: 2,
  },
  {
    kind: 'video',
    mimeType: 'video/VP8',
    clockRate: 90000,
    parameters: {
      'x-google-start-bitrate': 1000,
    },
  },
]

peers.on('connection', async socket => {

  console.log('[connection]');

  socket.emit('connection-success', {
    socketId: socket.id
  })
  
  socket.on('disconnect', () => {
    // do some cleanup
    console.log('[disconnect]')
  })
  
  socket.on('create-router', async (data) => {
    const routerId = data.assetId;
    
    console.log('[create-router]', routerId)

    routers[routerId] = await worker.createRouter({ mediaCodecs })
    // console.log('🔴 Create routers', routers);

    // for (const key in routers) {
    //   if (Object.hasOwnProperty.call(routers, key)) {
    //     const element = routers[key];
    //     console.log('🔴', key, element);
    //   }
    // }
  
    // Client emits a request for RTP Capabilities
    // This event responds to the request
    socket.on('getRtpCapabilities', (callback) => {
      console.log('[getRtpCapabilities]')
  
      const rtpCapabilities = routers[routerId].rtpCapabilities
  
      // call callback from the client and send back the rtpCapabilities
      callback({ rtpCapabilities })
    })
  
    // Client emits a request to create server side Transport
    // We need to differentiate between the producer and consumer transports
    socket.on('createWebRtcTransport', async ({ sender }, callback) => {
      console.log(`Is this a sender request? ${sender}`)
      // The client indicates if it is a producer or a consumer
      // if sender is true, indicates a producer else a consumer
      if (sender)
        producerTransport = await createWebRtcTransport(routerId, callback)
      else
        consumerTransport = await createWebRtcTransport(routerId, callback)
    })
  
      // see client's socket.emit('transport-connect', ...)
      socket.on('transport-connect', async ({ dtlsParameters }) => {
        console.log('DTLS PARAMS... ', { dtlsParameters })
        await producerTransport.connect({ dtlsParameters })
      })
  
        // see client's socket.emit('transport-produce', ...)
    socket.on('transport-produce', async ({ kind, rtpParameters, appData }, callback) => {
      // call produce based on the prameters from the client
      producer = await producerTransport.produce({
        kind,
        rtpParameters,
      })
  
      console.log('Producer ID:', producer.id, producer.kind)
  
      producer.on('transportclose', () => {
        console.log('transport for this producer closed ')
        producer.close()
      })
  
      // Send back to the client the Producer's id
      callback({
        id: producer.id
      })
    })
    // see client's socket.emit('transport-recv-connect', ...)
    socket.on('transport-recv-connect', async ({ dtlsParameters }) => {
      console.log(`DTLS PARAMS: ${dtlsParameters}`)
      await consumerTransport.connect({ dtlsParameters })
    })
  
    socket.on('consume', async ({ rtpCapabilities }, callback) => {
      try {
        console.log('[consume] Producer ID:', producer.id, producer.kind)
        // check if the routers can consume the specified producer
        if (routers[routerId].canConsume({
          producerId: producer.id,
          rtpCapabilities
        })) {
          // transport can now consume and return a consumer
          consumer = await consumerTransport.consume({
            producerId: producer.id,
            rtpCapabilities,
            paused: true,
          })
          
          consumer.on('transportclose', () => {
            console.log('transport close from consumer')
          })
  
          consumer.on('producerclose', () => {
            console.log('producer of consumer closed')
          })
  
          // from the consumer extract the following params
          // to send back to the Client
          const params = {
            id: consumer.id,
            producerId: producer.id,
            kind: consumer.kind,
            rtpParameters: consumer.rtpParameters,
          }
          // send the parameters to the client
          callback({ params })
        } else {
          console.log("Can't consume!!!", routers[routerId].canConsume());
        }
      } catch (error) {
        console.log(error.message)
        callback({
          params: {
            error: error
          }
        })
      }
    })
  
    socket.on('consumer-resume', async () => {
      console.log('consumer resume')
      await consumer.resume()
    })

  })
})


const createWebRtcTransport = async (routerId, callback) => {
  try {
    // https://mediasoup.org/documentation/v3/mediasoup/api/#WebRtcTransportOptions
    const webRtcTransport_options = {
      listenIps: [
        {
          ip: '0.0.0.0', // replace with relevant IP address
          announcedIp: '127.0.0.1',
        }
      ],
      enableUdp: true,
      enableTcp: true,
      preferUdp: true,
    }

    // https://mediasoup.org/documentation/v3/mediasoup/api/#routers-createWebRtcTransport
    let transport = await routers[routerId].createWebRtcTransport(webRtcTransport_options)
    console.log(`transport id: ${transport.id}`)

    transport.on('dtlsstatechange', dtlsState => {
      if (dtlsState === 'closed') {
        transport.close()
      }
    })

    transport.on('close', () => {
      console.log('transport closed')
    })

    // send back to the client the following prameters
    callback({
      // https://mediasoup.org/documentation/v3/mediasoup-client/api/#TransportOptions
      params: {
        id: transport.id,
        iceParameters: transport.iceParameters,
        iceCandidates: transport.iceCandidates,
        dtlsParameters: transport.dtlsParameters,
      }
    })

    return transport

  } catch (error) {
    console.log(error)
    callback({
      params: {
        error: error
      }
    })
  }
}