import dgram, { RemoteInfo } from 'dgram'
import { UdpSocketCommunicator } from '../socket_communicator/udp_socket_communicator'
import { OperationHandler } from '../operations_base/operation_handler'
import { GeneralOperations } from '../operations_custom/general_operations'

export class UdpServer {
  private readonly udpServer: dgram.Socket
  private readonly operationHandler: OperationHandler
  private readonly port: number
  private readonly host: string

  constructor(host: string, port: number) {
    this.udpServer = dgram.createSocket('udp4')
    this.operationHandler = OperationHandler.getInstance()
    this.host = host
    this.port = port

    // Load only the GeneralOperations into the operation handler
    this.operationHandler.loadPlugin(new GeneralOperations())
  }

  // Unified logging function
  private log(message: string, level: 'log' | 'error' = 'log'): void {
    const prefix = '[UdpServer]'
    if (level === 'error') {
      console.error(`${prefix} ${message}`)
    } else {
      console.log(`${prefix} ${message}`)
    }
  }

  // Start the UDP server
  public start(): void {
    this.udpServer.on('message', this.handleUdpMessages.bind(this))
    this.udpServer.on('error', this.handleError.bind(this))
    this.udpServer.on('listening', this.handleListening.bind(this))

    // Bind the server to the UDP port and host
    this.udpServer.bind(this.port, this.host)
  }

  // Handle incoming UDP messages
  private async handleUdpMessages(msg: Buffer, rinfo: RemoteInfo): Promise<void> {
    const ip = rinfo.address
    const port = rinfo.port

    this.log(`Received message from ${ip}:${port}`)

    // Create a temporary communicator for the incoming message
    const communicator = new UdpSocketCommunicator(this.udpServer, ip, port, this.operationHandler)

    // Process the incoming message using the communicator
    await communicator.handleIncomingMessage(msg.toString())

    const communicatorResult = communicator.getHandlerResult()
    if (communicatorResult) {
      // Send response back to the client using the temporary communicator
      try {
        await communicator.sendMessage(
          communicatorResult.operationCode,
          communicatorResult.metaInfo,
        )
        this.log(`Sent response to ${ip}:${port}`)
      } catch (error: any) {
        this.log(`Error sending response to ${ip}:${port}: ${error.message}`, 'error')
      }
    }
  }

  // Handle UDP server errors
  private handleError(err: Error): void {
    this.log(`UDP server error:\n${err.stack}`, 'error')
  }

  // Handle when the UDP server starts listening
  private handleListening(): void {
    const address = this.udpServer.address()
    this.log(`UDP server listening on ${address.address}:${address.port}`)
  }
}