// 1. Import the GenosDB library
import { gdb } from "https://cdn.jsdelivr.net/npm/genosdb@latest/dist/index.min.js"

// 2. Initialize GenosDB (the name is the room ID)
const db = await gdb("p2p-db", { rtc: true }) // (rtc: true) for realtime updates

const room = db.room

// 3. Create a channel for data messages
const dataChannel = room.channel("example-action")

// 4. Listen for peer lifecycle events
room.on("peer:join", (peerId) => console.log(`${peerId} joined the channel`))
room.on("peer:leave", (peerId) => console.log(`${peerId} left the channel`))

// 5. Publish data to the channel
function publishData(data) {
  console.log(`Publishing data: ${JSON.stringify(data)}`)
  dataChannel.send(data) // Send to all peers
}

// 6. Subscribe to incoming data
dataChannel.on("message", (data, peerId) => {
  console.log(`Received data from ${peerId}: ${JSON.stringify(data)}`)
  // Process the received data here
})

// Example usage
window.addEventListener("userAction", (event) => {
  const data = { action: event.type, payload: event.detail }
  publishData(data) // Send user action data to all peers
})

// Object to store audio instances for each peer
const peerAudios = {}

// Get access to the user's microphone
navigator.mediaDevices
  .getUserMedia({ audio: true, video: false })
  .then((selfStream) => {
    // Send the stream to all peers in the room. GenosRTC handles sending
    // it to current and future peers.
    db.room.addStream(selfStream)
  })
  .catch((error) => console.error("Error accessing microphone:", error))

// Handle incoming audio streams from other peers
db.room.on("stream:add", (stream, peerId) => {
  // Only process if the stream has audio tracks
  if (stream.getAudioTracks().length > 0) {
    console.log(`Received audio stream from peer ${peerId}`)
    // Create an audio element for the incoming stream
    const audio = new Audio()
    audio.srcObject = stream
    audio.autoplay = true

    // Store the audio instance for future reference
    peerAudios[peerId] = audio
  }
})

// Clean up when a peer leaves
db.room.on("peer:leave", (peerId) => {
  if (peerAudios[peerId]) {
    peerAudios[peerId].pause() // Pause the audio
    delete peerAudios[peerId] // Remove the reference
  }
})

// Object to store video elements for each peer
const peerVideos = {}
const videoContainer = document.getElementById("videos")

// Get access to the user's webcam
navigator.mediaDevices
  .getUserMedia({ audio: true, video: true })
  .then((selfStream) => {
    // Send the stream to all peers in the room
    db.room.addStream(selfStream)
  })
  .catch((error) => console.error("Error accessing webcam:", error))

// Handle incoming video streams from other peers
db.room.on("stream:add", (stream, peerId) => {
  console.log(`Received video stream from peer ${peerId}`)
  let video = peerVideos[peerId]

  // If this peer hasn't sent a stream before, create a video element
  if (!video) {
    video = document.createElement("video")
    video.autoplay = true
    video.playsInline = true // Important for mobile browsers

    // Add the video element to the DOM
    videoContainer.appendChild(video)
    peerVideos[peerId] = video
  }

  // Set the incoming stream as the source for the video element
  video.srcObject = stream
})

// Clean up when a peer leaves
db.room.on("peer:leave", (peerId) => {
  if (peerVideos[peerId]) {
    peerVideos[peerId].remove() // Remove the video element from the DOM
    delete peerVideos[peerId] // Delete the reference
  }
})

// 2. Initialize a secure room with encryption
const db = await gdb("file-room", { rtc: true, password: "secure-password" })

const room = db.room

// 3. Create a data channel for file transfers
const fileChannel = room.channel("file-transfer")

// 4. Handle incoming files
fileChannel.on("message", (message, peerId) => {
  // We expect the message to be an object with metadata and the file payload
  const { metadata, payload } = message
  console.log(
    `Received a file (${metadata.name}) from ${peerId} with type ${metadata.type}`
  )

  // Logic to save the file (e.g., create a Blob and a download link)
  const blob = new Blob([payload], { type: metadata.type })
  const link = document.createElement("a")
  link.href = URL.createObjectURL(blob)
  link.download = metadata.name
  link.click()
  URL.revokeObjectURL(link.href)
  alert(`Received and downloaded file: ${metadata.name}`)
})

// 5. Handle file selection and sending
document
  .getElementById("fileInput")
  .addEventListener("change", async (event) => {
    const file = event.target.files[0]
    if (!file) return

    // Read the file as an ArrayBuffer
    const buffer = await file.arrayBuffer()

    // Package the file data and metadata into a single object
    const message = {
      metadata: { name: file.name, type: file.type, id: `file-${Date.now()}` },
      payload: buffer,
    }

    // Send the object to all peers
    fileChannel.send(message)

    console.log("File sent successfully!")
  })

// Enable cellular mesh
const db = await gdb("large-event", { rtc: { cells: true } })

// The API remains identical - your existing code works unchanged
const chat = db.room.channel("chat")
chat.send({ text: "Hello everyone!" })