{"Http_Proxy", protocol.HTTP_PROXY},
		{"HTTP_PROXY", protocol.HTTP_PROXY},
		{"https", protocol.HTTPS},
		{"http2", protocol.HTTP2},
		{"grpc", protocol.GRPC},
		{"grpc-web", protocol.GRPCWeb},
		{"gRPC-Web", protocol.GRPCWeb},
		{"grpc-Web", protocol.GRPCWeb},
		{"udp", protocol.UDP},
		{"Mongo", protocol.Mongo},
		{"mongo", protocol.Mongo},
		{"MONGO", protocol.Mongo},
		{"Redis", protocol.Redis},
		{"redis", protocol.Redis},

// protocol sniffing is enabled.
var wellKnownPorts = sets.New[int32](
	SMTP,
	DNS,
	MySQL,
	MongoDB,
)

var (
	grpcWeb    = string(protocol.GRPCWeb)
	grpcWebLen = len(grpcWeb)
)

// ConvertProtocol from k8s protocol and port name
func ConvertProtocol(port int32, portName string, proto corev1.Protocol, appProto *string) protocol.Instance {

type Instance string

func (i Instance) String() string {
	return string(i)
}

const (
	// GRPC declares that the port carries gRPC traffic.
	GRPC Instance = "GRPC"
	// GRPCWeb declares that the port carries gRPC traffic.
	GRPCWeb Instance = "GRPC-Web"
	// HTTP declares that the port carries HTTP/1.1 traffic.
	// Note that HTTP/1.0 or earlier may not be supported by the proxy.
	HTTP Instance = "HTTP"

		Name: wellknown.Fault,
		ConfigType: &hcm.HttpFilter_TypedConfig{
			TypedConfig: protoconv.MessageToAny(&fault.HTTPFault{}),
		},
	}
	GrpcWeb = &hcm.HttpFilter{
		Name: wellknown.GRPCWeb,
		ConfigType: &hcm.HttpFilter_TypedConfig{
			TypedConfig: protoconv.MessageToAny(&grpcweb.GrpcWeb{}),
		},
	}
	GrpcStats = &hcm.HttpFilter{
		Name: wellknown.HTTPGRPCStats,
		ConfigType: &hcm.HttpFilter_TypedConfig{

			expectedProto: protocol.HTTPS,
		},
		{
			name:          "resolves grpc-web",
			portName:      "grpc-web-x",
			expectedProto: protocol.GRPCWeb,
		},
		{
			name:          "makes sure grpc-web is not resolved incorrectly",
			portName:      "grpcweb-x",
			expectedProto: protocol.Unsupported,
		},
		{
			name:          "resolves based on known ports",
			port:          3306, // mysql

	// GRPCHTTP1Bridge HTTP filter
	GRPCHTTP1Bridge = "envoy.filters.http.grpc_http1_bridge"
	// GRPCJSONTranscoder HTTP filter
	GRPCJSONTranscoder = "envoy.filters.http.grpc_json_transcoder"
	// GRPCWeb HTTP filter
	GRPCWeb = "envoy.filters.http.grpc_web"
	// Gzip HTTP filter
	Gzip = "envoy.filters.http.gzip"
	// IPTagging HTTP filter
	IPTagging = "envoy.filters.http.ip_tagging"
	// HTTPRateLimit filter

func ModelProtocolToListenerProtocol(p protocol.Instance) ListenerProtocol {
	switch p {
	case protocol.HTTP, protocol.HTTP2, protocol.HTTP_PROXY, protocol.GRPC, protocol.GRPCWeb:
		return ListenerProtocolHTTP
	case protocol.TCP, protocol.HTTPS, protocol.TLS,
		protocol.Mongo, protocol.Redis, protocol.MySQL:
		return ListenerProtocolTCP
	case protocol.UDP:
		return ListenerProtocolUnknown

		wellknown.Fault:                       "envoy.fault",
		wellknown.GRPCHTTP1Bridge:             "envoy.grpc_http1_bridge",
		wellknown.GRPCJSONTranscoder:          "envoy.grpc_json_transcoder",
		wellknown.GRPCWeb:                     "envoy.grpc_web",
		wellknown.Gzip:                        "envoy.gzip",
		wellknown.HealthCheck:                 "envoy.health_check",
		wellknown.IPTagging:                   "envoy.ip_tagging",

		{8888, "grpc", nil, corev1.ProtocolTCP, protocol.GRPC},
		{8888, "grpc-test", nil, corev1.ProtocolTCP, protocol.GRPC},
		{8888, "grpc-web", nil, corev1.ProtocolTCP, protocol.GRPCWeb},
		{8888, "grpc-web-test", nil, corev1.ProtocolTCP, protocol.GRPCWeb},
		{8888, "mongo", nil, corev1.ProtocolTCP, protocol.Mongo},
		{8888, "mongo-test", nil, corev1.ProtocolTCP, protocol.Mongo},
		{8888, "redis", nil, corev1.ProtocolTCP, protocol.Redis},

	return &portGenerator{
		next: map[protocol.Instance]int{
			protocol.HTTP:    httpBase,
			protocol.HTTPS:   httpsBase,
			protocol.TLS:     httpsBase,
			protocol.TCP:     tcpBase,
			protocol.GRPCWeb: grpcBase,
			protocol.GRPC:    grpcBase,
			protocol.Mongo:   tcpBase,
			protocol.MySQL:   tcpBase,
			protocol.Redis:   tcpBase,
			protocol.UDP:     tcpBase,
		},
		used: make(map[int]struct{}),
	}
}