Pattern for connecting one to one between two http routes?

[1CTdev]

I have the following problem, what is the optimal pattern for creating a system where there is two types of connections can connect to each other one to one dynamically and one at a time. I have the following code and its """works""" but it it looks very messy and doesn't feel right. Any input is appreciated.

type socket struct {
	lock     *sync.Mutex
	sendChan    chan []byte
	receiveChan chan []byte
}

var Id int = 1

var ConnectionsLock sync.Mutex
var Connections = make(map[string]*socket)

func panel(c *gin.Context) {
	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		log.Println(err)
		return
	}

	defer conn.Close()

	var panelwrite = make(chan []byte)

	var availablesockets []string

	for implant, _ := range Connections {
		availablesockets = append(availablesockets, implant)

	}

	availablesocketsMessage, err := json.Marshal(availablesockets)
	if err != nil {
		log.Println(err)
		return
	}

	var wait = make(chan bool)

	go func(conn *websocket.Conn) {
		for write := range panelwrite {
			err := conn.WriteMessage(websocket.BinaryMessage, write)
			if err != nil {
				log.Println(err)
				return
			}
		}
	}(conn)

	panelwrite <- common.SerializeStringUTF32(31, string(availablesocketsMessage))

	var newcurrent = make(chan bool)

	var current string

	go func(conn *websocket.Conn) {
		for {
			_, b, err := conn.ReadMessage()
			if err != nil {
				wait <- true
				log.Println(err)
				return
			}
			switch b[0] {
			case 31:
				if _, ok := Connections[current]; ok {
					if Connections[current].receiveChan != nil {
						Connections[current].receiveChan <- []byte{33}
					}
					current = ""
				}

				ConnectionsLock.Lock()
				new := common.DeSerializeStringUTF32(b)
				if _, ok := Connections[new]; ok {
					if Connections[new].lock.TryLock() {
						current = new
						ConnectionsLock.Unlock()
						newcurrent <- true
					} else {
						panelwrite <- common.SerializeStringUTF32(37, "already in use")
						ConnectionsLock.Unlock()
						continue
					}
				} else {
					panelwrite <- common.SerializeStringUTF32(37, "selected non-existent socket")
					ConnectionsLock.Unlock()
					continue
				}
			default:
				if _, ok := Connections[current]; ok {
					if Connections[current].sendChan != nil {
						Connections[current].sendChan <- b
					}
				}
			}
		}
	}(conn)

	go func(conn *websocket.Conn) {
		for <-newcurrent {
			thisclient := current
			if Connections[thisclient].receiveChan != nil && Connections[thisclient].sendChan != nil {
				// empty the channel from previous unread messages
				for len(Connections[thisclient].receiveChan) > 0 {
					<-Connections[thisclient].receiveChan
				}

			clientloop:
				for message := range Connections[thisclient].receiveChan {
					switch message[0] {
					case 33:
						break clientloop
					case 99:
						ConnectionsLock.Lock()
						if _, ok := Connections[thisclient]; ok {
							Connections[thisclient].lock.Unlock()
						}
						ConnectionsLock.Unlock()
						return
					case 30:
						if len(message) == 2 && message[1] == 0 {
							panelwrite <- message
							break clientloop

						}
					default:
						panelwrite <- message
					}
				}
				ConnectionsLock.Lock()
				if _, ok := Connections[thisclient]; ok {
					Connections[thisclient].lock.Unlock()
				}
				ConnectionsLock.Unlock()
			} else {
				panelwrite <- common.SerializeStringUTF32(37, "selected non-existent socket")
			}
		}
	}(conn)

	<-wait
	if _, ok := Connections[current]; ok {
		Connections[current].receiveChan <- []byte{99} //exit receive goroutine
	}
}

func Connection(c *gin.Context) {
	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		log.Println(err)
		return
	}
	defer conn.Close()
	Id++

	clientname := fmt.Sprintf("%d - %s", Id, ip)

	ConnectionsLock.Lock()
	Connections[clientname] = &socket{
		&sync.Mutex{},
		make(chan []byte),
		make(chan []byte),
	}
	ConnectionsLock.Unlock()

	defer func() {
		ConnectionsLock.Lock()
		delete(Connections, clientname)
		ConnectionsLock.Unlock()
	}()

	var wait = make(chan bool)

	go func() {
		for {
			_, b, err := conn.ReadMessage()
			if err != nil {
				log.Println(err)

				select {
				case Connections[clientname].receiveChan <- []byte{30, 0}:
				default:
				}

				wait <- true
				break
			} else {
				Connections[clientname].receiveChan <- b
			}
		}
	}()

	go func() {
		for message := range Connections[clientname].sendChan {
			err := conn.WriteMessage(websocket.BinaryMessage, message)
			if err != nil {
				log.Println(err)
				return
			}
		}
	}()

	<-wait
}