/* global Pear */
import Runtime from 'pear-electron'
import Bridge from 'pear-bridge'

// Initialize the Pear-Electron runtime
const runtime = new Runtime()

// Bridge enables HTTP-like patterns over P2P
const bridge = new Bridge()
await bridge.ready()

// Start the runtime with the bridge
const pipe = runtime.start({ bridge })

// Cleanup handler when the app closes
Pear.teardown(async () => {
  if (pipe && typeof pipe.end === 'function') {
    pipe.end()
  } else if (pipe && typeof pipe.destroy === 'function') {
    pipe.destroy()
  }
})

const state = {
  board: Array(9).fill(null),  // 3x3 board as flat array
  mySymbol: null,               // 'X' or 'O'
  currentTurn: 'X',             // X always starts
  isMyTurn: false,              // Controls UI interaction
  gameOver: false,              // Prevents moves after game ends
  isHost: false,                // Host is X, guest is O
  connected: false,             // P2P connection status
  peer: null                    // The peer connection stream
}

const WINNING_COMBOS = [
  [0, 1, 2], [3, 4, 5], [6, 7, 8], // Rows
  [0, 3, 6], [1, 4, 7], [2, 5, 8], // Columns
  [0, 4, 8], [2, 4, 6]             // Diagonals
]

function checkWinner() {
  for (const combo of WINNING_COMBOS) {
    const [a, b, c] = combo
    if (state.board[a] &&
        state.board[a] === state.board[b] &&
        state.board[a] === state.board[c]) {
      return { winner: state.board[a], combo }
    }
  }

  // Check for draw
  if (state.board.every(cell => cell !== null)) {
    return { winner: null, combo: null }
  }

  return null // Game continues
}

import Hyperswarm from 'hyperswarm'
import crypto from 'hypercore-crypto'
import b4a from 'b4a'

async function hostGame() {
  // Create a new Hyperswarm instance
  swarm = new Hyperswarm()

  // Generate a random 32-byte topic
  topic = crypto.randomBytes(32)

  // Listen for incoming connections
  swarm.on('connection', (conn, info) => {
    handleConnection(conn)
  })

  // Join the DHT as a server (accepting connections)
  const discovery = swarm.join(topic, {
    server: true,   // Accept incoming connections
    client: false   // Don't seek other servers
  })

  // Wait for the topic to be fully announced
  await discovery.flushed()

  // Display the room code (topic as hex string)
  const roomCode = b4a.toString(topic, 'hex')
  console.log('Share this code:', roomCode)
}

async function joinGame(roomCodeHex) {
  swarm = new Hyperswarm()

  // Convert the hex string back to a 32-byte buffer
  topic = b4a.from(roomCodeHex, 'hex')

  swarm.on('connection', (conn, info) => {
    handleConnection(conn)
  })

  // Join the DHT as a client (seeking servers)
  swarm.join(topic, {
    server: false,  // Don't accept connections
    client: true    // Seek servers announcing this topic
  })

  // Wait for connection attempts to complete
  await swarm.flush()
}

function handleConnection(conn) {
  // Prevent multiple connections
  if (state.peer) {
    conn.destroy()
    return
  }

  state.peer = conn
  state.connected = true

  // Handle incoming data
  conn.on('data', (data) => {
    const message = JSON.parse(data.toString())
    handleMessage(message)
  })

  // Handle disconnection
  conn.on('close', () => {
    state.peer = null
    state.connected = false
  })
}

// Sending a move
function sendMove(cellIndex) {
  const message = { type: 'move', index: cellIndex }
  state.peer.write(JSON.stringify(message))
}

// Requesting a new game
function requestNewGame() {
  const message = { type: 'new-game' }
  state.peer.write(JSON.stringify(message))
}

// Handling incoming messages
function handleMessage(message) {
  switch (message.type) {
    case 'move':
      // Opponent made a move
      applyMove(message.index)
      break
    case 'new-game':
      // Opponent wants a rematch
      resetGame()
      break
  }
}

Pear.teardown(async () => {
  // Cleanup logic
})