How to connect to the CDP WebSocket server in Golang?

Question

I want to send CDP commands to WebSocket server exposed by chrome browser.
For example, I create a new session on selenium and get WebSocket url as -> ws://172.20.10.2:4444/session/335d5805e9d98f3c37af004fa91e0f6e/se/cdp Now I want to send CDP commands to this WebSocket connection and get results. Sample client code :

package main

import (
    "encoding/json"
    "fmt"
    "github.com/gorilla/websocket"
    "log"
    "net/url"
)

type message1 struct {
    Id     int    `json:"id"`
    Result Result `json:"result"`
}
type Result struct {
    TargetInfo []TargetInfo `json:"targetInfos"`
}
type TargetInfo struct {
    TargetId string `json:"targetId"`
}

type message2 struct {
    Id     int       `json:"id"`
    Method string    `json:"method"`
    Params Parameter `json:"params"`
}

type Parameter struct {
    TargetId string `json:"targetId"`
    Flatten  bool   `json:"flatten"`
}

type message3 struct {
    Id         int                `json:"id"`
    Method     string             `json:"method"`
    SessionId  string             `json:"sessionId"`
    Parameters EmulationParameter `json:"params"`
}
type EmulationParameter struct {
    Width             int  `json:"width"`
    Height            int  `json:"height"`
    DeviceScaleFactor int  `json:"deviceScaleFactor"`
    Mobile            bool `json:"mobile"`
}

type Response2 struct {
    Method    string          `json:"method"`
    Parameter SessionResponse `json:"params"`
}

type SessionResponse struct {
    SessionId string `json:"sessionId"`
}

type message4 struct {
    Id         int                 `json:"id"`
    Method     string              `json:"method"`
    SessionId  string              `json:"sessionId"`
    Parameters ScreenshotParameter `json:"params"`
}

type ScreenshotParameter struct {
    Width int `json:"width,omitempty"`
}

func main() {

    hostURL := "172.20.10.2:4444"
    pathURL := "/session/dd44b246de3261c405cb9fcb017ab59a/se/cdp"
    u := url.URL{Scheme: "ws", Host: hostURL, Path: pathURL}
    c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer c.Close()
    messageChannel := make(chan string)
    go func() {
        for {
            _, message, err := c.ReadMessage()

            //err = c.ReadJSON(p)

            if err != nil {
                log.Println("read:", err)
                return
            }
            messageChannel <- string(message)
            fmt.Println(string(message))
        }
    }()

    message := "{\"id\":1,\"method\":\"Target.getTargets\"}"
    //err = c.WriteJSON(websocket.TextMessage, []byte(message))
    err = c.WriteMessage(websocket.TextMessage, []byte(message))
    if err != nil {
        log.Println("write:", err)
        return
    }
    response := <-messageChannel
    fmt.Println(response)

    decodedResponse := message1{}
    json.Unmarshal([]byte(response), &decodedResponse)
    fmt.Println(decodedResponse)
    fmt.Println(decodedResponse.Result.TargetInfo[0].TargetId)

    temp := message2{}
    temp.Id = 2
    temp.Method = "Target.attachToTarget"
    temp.Params.Flatten = true
    temp.Params.TargetId = decodedResponse.Result.TargetInfo[0].TargetId
    event2, _ := json.Marshal(temp)
    err = c.WriteMessage(websocket.TextMessage, event2)
    if err != nil {
        log.Println("write:", err)
        return
    }
    response2 := <-messageChannel
    fmt.Println(response2)
    decodedResponse2 := Response2{}
    json.Unmarshal([]byte(response2), &decodedResponse2)
    fmt.Println("The session Id is")
    fmt.Println(decodedResponse2.Parameter.SessionId)
    width := 645
    height := 9651
    scale := 2

    temp2 := message3{}
    temp2.Id = 1
    temp2.SessionId = decodedResponse2.Parameter.SessionId
    temp2.Method = "Emulation.setDeviceMetricsOverride"
    temp2.Parameters.DeviceScaleFactor = scale
    temp2.Parameters.Height = height
    temp2.Parameters.Width = width
    temp2.Parameters.Mobile = false
    event3, _ := json.Marshal(temp2)
    err = c.WriteMessage(websocket.TextMessage, event3)
    if err != nil {
        log.Println("write:", err)
        return
    }
    response3 := <-messageChannel
    fmt.Println(response3)

    temp3 := message4{}
    temp3.Id = 1
    temp3.SessionId = decodedResponse2.Parameter.SessionId
    temp3.Method = "Page.captureScreenshot"
    event4, _ := json.Marshal(temp3)
    err = c.WriteMessage(websocket.TextMessage, event4)
    if err != nil {
        log.Println("write:", err)
        return
    }

    response4 := <-messageChannel
    fmt.Println(response4)

}

I wasn't able to reuse this part of the code to send CDP commands to the WebSocket. I want a simple example CDP command.