package tcp

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/traefik/traefik/v2/pkg/tcp"
)

func Test_HostSNICatchAll(t *testing.T) {
	testCases := []struct {
		desc       string
		rule       string
		isCatchAll bool
	}{
		{
			desc: "HostSNI(`example.com`) is not catchAll",
			rule: "HostSNI(`example.com`)",
		},
		{
			desc:       "HostSNI(`*`) is catchAll",
			rule:       "HostSNI(`*`)",
			isCatchAll: true,
		},
		{
			desc:       "HostSNIRegexp(`^.*$`) is not catchAll",
			rule:       "HostSNIRegexp(`.*`)",
			isCatchAll: false,
		},
	}

	for _, test := range testCases {
		test := test
		t.Run(test.desc, func(t *testing.T) {
			t.Parallel()

			muxer, err := NewMuxer()
			require.NoError(t, err)

			err = muxer.AddRoute(test.rule, 0, tcp.HandlerFunc(func(conn tcp.WriteCloser) {}))
			require.NoError(t, err)

			handler, catchAll := muxer.Match(ConnData{
				serverName: "example.com",
			})
			require.NotNil(t, handler)
			assert.Equal(t, test.isCatchAll, catchAll)
		})
	}
}

func Test_HostSNI(t *testing.T) {
	testCases := []struct {
		desc       string
		rule       string
		serverName string
		buildErr   bool
		match      bool
	}{
		{
			desc:     "Empty",
			buildErr: true,
		},
		{
			desc:     "Invalid HostSNI matcher (empty host)",
			rule:     "HostSNI(``)",
			buildErr: true,
		},
		{
			desc:     "Invalid HostSNI matcher (too many parameters)",
			rule:     "HostSNI(`example.com`, `example.org`)",
			buildErr: true,
		},
		{
			desc:     "Invalid HostSNI matcher (globing sub domain)",
			rule:     "HostSNI(`*.com`)",
			buildErr: true,
		},
		{
			desc:     "Invalid HostSNI matcher (non ASCII host)",
			rule:     "HostSNI(`🦭.com`)",
			buildErr: true,
		},
		{
			desc:       "Valid HostSNI matcher - puny-coded emoji",
			rule:       "HostSNI(`xn--9t9h.com`)",
			serverName: "xn--9t9h.com",
			match:      true,
		},
		{
			desc:       "Valid HostSNI matcher - puny-coded emoji but emoji in server name",
			rule:       "HostSNI(`xn--9t9h.com`)",
			serverName: "🦭.com",
		},
		{
			desc:       "Matching hosts",
			rule:       "HostSNI(`example.com`)",
			serverName: "example.com",
			match:      true,
		},
		{
			desc:       "No matching hosts",
			rule:       "HostSNI(`example.com`)",
			serverName: "example.org",
		},
		{
			desc:       "Matching globing host `*`",
			rule:       "HostSNI(`*`)",
			serverName: "example.com",
			match:      true,
		},
		{
			desc:       "Matching globing host `*` and empty server name",
			rule:       "HostSNI(`*`)",
			serverName: "",
			match:      true,
		},
		{
			desc:       "Matching host with trailing dot",
			rule:       "HostSNI(`example.com.`)",
			serverName: "example.com.",
			match:      true,
		},
		{
			desc:       "Matching host with trailing dot but not in server name",
			rule:       "HostSNI(`example.com.`)",
			serverName: "example.com",
			match:      true,
		},
		{
			desc:       "Matching hosts with subdomains",
			rule:       "HostSNI(`foo.example.com`)",
			serverName: "foo.example.com",
			match:      true,
		},
	}

	for _, test := range testCases {
		test := test
		t.Run(test.desc, func(t *testing.T) {
			t.Parallel()

			muxer, err := NewMuxer()
			require.NoError(t, err)

			err = muxer.AddRoute(test.rule, 0, tcp.HandlerFunc(func(conn tcp.WriteCloser) {}))
			if test.buildErr {
				require.Error(t, err)
				return
			}
			require.NoError(t, err)

			meta := ConnData{
				serverName: test.serverName,
			}

			handler, _ := muxer.Match(meta)
			require.Equal(t, test.match, handler != nil)
		})
	}
}

func Test_HostSNIRegexp(t *testing.T) {
	testCases := []struct {
		desc     string
		rule     string
		expected map[string]bool
		buildErr bool
		match    bool
	}{
		{
			desc:     "Empty",
			buildErr: true,
		},
		{
			desc:     "Invalid HostSNIRegexp matcher (empty host)",
			rule:     "HostSNIRegexp(``)",
			buildErr: true,
		},
		{
			desc:     "Invalid HostSNIRegexp matcher (non ASCII host)",
			rule:     "HostSNIRegexp(`🦭.com`)",
			buildErr: true,
		},
		{
			desc:     "Invalid HostSNIRegexp matcher (invalid regexp)",
			rule:     "HostSNIRegexp(`(example.com`)",
			buildErr: true,
		},
		{
			desc:     "Invalid HostSNIRegexp matcher (too many parameters)",
			rule:     "HostSNIRegexp(`example.com`, `example.org`)",
			buildErr: true,
		},
		{
			desc: "valid HostSNIRegexp matcher",
			rule: "HostSNIRegexp(`^example\\.(com|org)$`)",
			expected: map[string]bool{
				"example.com":  true,
				"example.com.": false,
				"EXAMPLE.com":  false,
				"example.org":  true,
				"exampleuorg":  false,
				"":             false,
			},
		},
		{
			desc: "valid HostSNIRegexp matcher with Traefik v2 syntax",
			rule: "HostSNIRegexp(`example.{tld:(com|org)}`)",
			expected: map[string]bool{
				"example.com":  false,
				"example.com.": false,
				"EXAMPLE.com":  false,
				"example.org":  false,
				"exampleuorg":  false,
				"":             false,
			},
		},
	}

	for _, test := range testCases {
		test := test
		t.Run(test.desc, func(t *testing.T) {
			t.Parallel()

			muxer, err := NewMuxer()
			require.NoError(t, err)

			err = muxer.AddRoute(test.rule, 0, tcp.HandlerFunc(func(conn tcp.WriteCloser) {}))
			if test.buildErr {
				require.Error(t, err)
				return
			}
			require.NoError(t, err)

			for serverName, match := range test.expected {
				meta := ConnData{
					serverName: serverName,
				}

				handler, _ := muxer.Match(meta)
				assert.Equal(t, match, handler != nil, serverName)
			}
		})
	}
}

func Test_ClientIP(t *testing.T) {
	testCases := []struct {
		desc     string
		rule     string
		expected map[string]bool
		buildErr bool
	}{
		{
			desc:     "Empty",
			buildErr: true,
		},
		{
			desc:     "Invalid ClientIP matcher (empty host)",
			rule:     "ClientIP(``)",
			buildErr: true,
		},
		{
			desc:     "Invalid ClientIP matcher (non ASCII host)",
			rule:     "ClientIP(`🦭/32`)",
			buildErr: true,
		},
		{
			desc:     "Invalid ClientIP matcher (too many parameters)",
			rule:     "ClientIP(`127.0.0.1`, `127.0.0.2`)",
			buildErr: true,
		},
		{
			desc: "valid ClientIP matcher",
			rule: "ClientIP(`20.20.20.20`)",
			expected: map[string]bool{
				"20.20.20.20": true,
				"10.10.10.10": false,
			},
		},
		{
			desc: "valid ClientIP matcher with CIDR",
			rule: "ClientIP(`20.20.20.20/24`)",
			expected: map[string]bool{
				"20.20.20.20": true,
				"20.20.20.40": true,
				"10.10.10.10": false,
			},
		},
	}

	for _, test := range testCases {
		test := test
		t.Run(test.desc, func(t *testing.T) {
			t.Parallel()

			muxer, err := NewMuxer()
			require.NoError(t, err)

			err = muxer.AddRoute(test.rule, 0, tcp.HandlerFunc(func(conn tcp.WriteCloser) {}))
			if test.buildErr {
				require.Error(t, err)
				return
			}
			require.NoError(t, err)

			for remoteIP, match := range test.expected {
				meta := ConnData{
					remoteIP: remoteIP,
				}

				handler, _ := muxer.Match(meta)
				assert.Equal(t, match, handler != nil, remoteIP)
			}
		})
	}
}

func Test_ALPN(t *testing.T) {
	testCases := []struct {
		desc     string
		rule     string
		expected map[string]bool
		buildErr bool
	}{
		{
			desc:     "Empty",
			buildErr: true,
		},
		{
			desc:     "Invalid ALPN matcher (TLS proto)",
			rule:     "ALPN(`acme-tls/1`)",
			buildErr: true,
		},
		{
			desc:     "Invalid ALPN matcher (empty parameters)",
			rule:     "ALPN(``)",
			buildErr: true,
		},
		{
			desc:     "Invalid ALPN matcher (too many parameters)",
			rule:     "ALPN(`h2`, `mqtt`)",
			buildErr: true,
		},
		{
			desc: "Valid ALPN matcher",
			rule: "ALPN(`h2`)",
			expected: map[string]bool{
				"h2":   true,
				"mqtt": false,
				"":     false,
			},
		},
	}

	for _, test := range testCases {
		test := test
		t.Run(test.desc, func(t *testing.T) {
			t.Parallel()

			muxer, err := NewMuxer()
			require.NoError(t, err)

			err = muxer.AddRoute(test.rule, 0, tcp.HandlerFunc(func(conn tcp.WriteCloser) {}))
			if test.buildErr {
				require.Error(t, err)
				return
			}
			require.NoError(t, err)

			for proto, match := range test.expected {
				meta := ConnData{
					alpnProtos: []string{proto},
				}

				handler, _ := muxer.Match(meta)
				assert.Equal(t, match, handler != nil, proto)
			}
		})
	}
}