Converting a TcpConn to a websocket connection

[ImmanuelSamuel]

How can we convert existing TcpConn to websocket using the net.websocket library. It has a handle_websocket function on the Server struct. So essentially is there a way to use existing code to implement the onmessage, onconnect, onclose handlers instead of doing it from scratch.

import net

fn main() {
  mut server := net.listen_tcp(.ip, ':9000')!
  laddr := server.addr()!
  eprintln('Server listening on: ${laddr} ...')

  for {
    mut conn := server.accept()!
    go handle_client(mut conn)
  }
}
fn handle_client(mut conn net.TcpConn) {
  defer { conn.close() or { panic(err) } }
  client_addr := conn.peer_addr() or { return }
  eprintln('> new client: ${client_addr}')
  mut reader := io.new_buffered_reader(reader: conn)
  defer { unsafe { reader.free() } }

  // Parse Headers
  mut line := reader.read_line() or { return }
  mut header := map[string]string{}
  header['path'] = line
  for { 
    line = reader.read_line() or { return }
    if line.starts_with('User-Agent:') { header['user-agent'] = line }
    else if line.starts_with('Sec-WebSocket-Key:') { header['wss-key'] = line.split(': ')[1] }
    else if line == '' { break }
  }

  // GET
  if header['path'] == 'GET /wss HTTP/1.1' { wss(mut conn, header); return }
  eprint('-----------------\n')
}
fn wss(mut conn net.TcpConn, header map[string]string) {
  eprint('Reached path: /wss /\n')
  // implement websocket here
  mut server := websocket.Server{}
  sc := server.handle_handshake(mut conn, header['wss-key']) or { return }
  
  // implement onmessage, onopen and onclose handlers

	 sc.server.on_connect(fn (mut s websocket.ServerClient) !bool {
	   eprintln('connected')
		slog('ws.on_connect, s.client_key: ${s.client_key}')
		// Here you can look att the client info and accept or not accept
		// just returning a true/false
		if s.resource_name != '/' {
			return false
		}
		return true
	}) or { return }
	sc.server.on_message(fn (mut ws websocket.Client, msg &websocket.Message) ! {
	   eprintln('got message')
		slog('s.on_message msg.opcode: ${msg.opcode} | msg.payload: ${msg.payload}')
		ws.write(msg.payload, msg.opcode) or {
			eprintln('ws.write err: ${err}')
			return err
		}
	})

}

the above seems to get message text-frame -> read: text -> sending on_message events
But the on_message handler in the code above is not reached - I do not see a on_connect event either.