package bind

import (
	"net"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/influxdata/telegraf/testutil"
	"github.com/stretchr/testify/assert"
)

func TestBindJsonStats(t *testing.T) {
	ts := httptest.NewServer(http.FileServer(http.Dir("testdata")))
	url := ts.Listener.Addr().String()
	host, port, _ := net.SplitHostPort(url)
	defer ts.Close()

	b := Bind{
		Urls:                 []string{ts.URL + "/json/v1"},
		GatherMemoryContexts: true,
		GatherViews:          true,
	}

	var acc testutil.Accumulator
	err := acc.GatherError(b.Gather)

	assert.Nil(t, err)

	// Use subtests for counters, since they are similar structure
	type fieldSet struct {
		fieldKey   string
		fieldValue int64
	}

	testCases := []struct {
		counterType string
		values      []fieldSet
	}{
		{
			"opcode",
			[]fieldSet{
				{"NOTIFY", 0},
				{"UPDATE", 0},
				{"IQUERY", 0},
				{"QUERY", 13},
				{"STATUS", 0},
			},
		},
		{
			"qtype",
			[]fieldSet{
				{"A", 2},
				{"AAAA", 2},
				{"PTR", 7},
				{"SRV", 2},
			},
		},
		{
			"nsstat",
			[]fieldSet{
				{"QrySuccess", 6},
				{"QryRecursion", 12},
				{"Requestv4", 13},
				{"QryNXDOMAIN", 4},
				{"QryAuthAns", 1},
				{"QryNxrrset", 1},
				{"QryNoauthAns", 10},
				{"QryUDP", 13},
				{"QryDuplicate", 1},
				{"QrySERVFAIL", 1},
				{"Response", 12},
			},
		},
		{
			"sockstat",
			[]fieldSet{
				{"TCP4Open", 118},
				{"UDP6Close", 112},
				{"UDP4Close", 333},
				{"TCP4Close", 119},
				{"TCP6Active", 2},
				{"UDP4Active", 2},
				{"UDP4RecvErr", 1},
				{"UDP4Open", 335},
				{"TCP4Active", 10},
				{"RawActive", 1},
				{"UDP6ConnFail", 112},
				{"TCP4Conn", 114},
				{"UDP6Active", 1},
				{"UDP6Open", 113},
				{"UDP4Conn", 333},
				{"UDP6SendErr", 112},
				{"RawOpen", 1},
				{"TCP4Accept", 6},
				{"TCP6Open", 2},
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.counterType, func(t *testing.T) {
			tags := map[string]string{
				"url":    url,
				"type":   tc.counterType,
				"source": host,
				"port":   port,
			}

			fields := map[string]interface{}{}

			for _, val := range tc.values {
				fields[val.fieldKey] = val.fieldValue
			}

			acc.AssertContainsTaggedFields(t, "bind_counter", fields, tags)
		})
	}

	// Subtest for memory stats
	t.Run("memory", func(t *testing.T) {
		tags := map[string]string{
			"url":    url,
			"source": host,
			"port":   port,
		}

		fields := map[string]interface{}{
			"block_size":   int64(13893632),
			"context_size": int64(3685480),
			"in_use":       int64(3064368),
			"lost":         int64(0),
			"total_use":    int64(18206566),
		}
		acc.AssertContainsTaggedFields(t, "bind_memory", fields, tags)
	})

	// Subtest for per-context memory stats
	t.Run("memory_context", func(t *testing.T) {
		assert.True(t, acc.HasInt64Field("bind_memory_context", "total"))
		assert.True(t, acc.HasInt64Field("bind_memory_context", "in_use"))
	})
}

func TestBindXmlStatsV2(t *testing.T) {
	ts := httptest.NewServer(http.FileServer(http.Dir("testdata")))
	url := ts.Listener.Addr().String()
	host, port, _ := net.SplitHostPort(url)
	defer ts.Close()

	b := Bind{
		Urls:                 []string{ts.URL + "/xml/v2"},
		GatherMemoryContexts: true,
		GatherViews:          true,
	}

	var acc testutil.Accumulator
	err := acc.GatherError(b.Gather)

	assert.Nil(t, err)

	// Use subtests for counters, since they are similar structure
	type fieldSet struct {
		fieldKey   string
		fieldValue int64
	}

	testCases := []struct {
		counterType string
		values      []fieldSet
	}{
		{
			"opcode",
			[]fieldSet{
				{"UPDATE", 238},
				{"QUERY", 102312374},
			},
		},
		{
			"qtype",
			[]fieldSet{
				{"ANY", 7},
				{"DNSKEY", 452},
				{"SSHFP", 2987},
				{"SOA", 100415},
				{"AAAA", 37786321},
				{"MX", 441155},
				{"IXFR", 157},
				{"CNAME", 531},
				{"NS", 1999},
				{"TXT", 34628},
				{"A", 58951432},
				{"SRV", 741082},
				{"PTR", 4211487},
				{"NAPTR", 39137},
				{"DS", 584},
			},
		},
		{
			"nsstat",
			[]fieldSet{
				{"XfrReqDone", 157},
				{"ReqEdns0", 441758},
				{"ReqTSIG", 0},
				{"UpdateRespFwd", 0},
				{"RespEDNS0", 441748},
				{"QryDropped", 16},
				{"RPZRewrites", 0},
				{"XfrRej", 0},
				{"RecQryRej", 0},
				{"QryNxrrset", 24423133},
				{"QryFORMERR", 0},
				{"ReqTCP", 1548156},
				{"UpdateDone", 0},
				{"QrySERVFAIL", 14422},
				{"QryRecursion", 2104239},
				{"Requestv4", 102312611},
				{"UpdateFwdFail", 0},
				{"QryReferral", 3},
				{"Response", 102301560},
				{"RespTSIG", 0},
				{"QrySuccess", 63811668},
				{"QryFailure", 0},
				{"RespSIG0", 0},
				{"ReqSIG0", 0},
				{"UpdateRej", 238},
				{"QryAuthAns", 72180718},
				{"UpdateFail", 0},
				{"QryDuplicate", 10879},
				{"RateDropped", 0},
				{"QryNoauthAns", 30106182},
				{"QryNXDOMAIN", 14052096},
				{"ReqBadSIG", 0},
				{"UpdateReqFwd", 0},
				{"RateSlipped", 0},
				{"TruncatedResp", 3787},
				{"Requestv6", 1},
				{"UpdateBadPrereq", 0},
				{"AuthQryRej", 0},
				{"ReqBadEDNSVer", 0},
			},
		},
		{
			"sockstat",
			[]fieldSet{
				{"FdwatchBindFail", 0},
				{"UDP6Open", 238269},
				{"UDP6SendErr", 238250},
				{"TCP4ConnFail", 0},
				{"TCP4Conn", 590},
				{"TCP6AcceptFail", 0},
				{"UDP4SendErr", 0},
				{"FDwatchConn", 0},
				{"TCP4RecvErr", 1},
				{"TCP4OpenFail", 0},
				{"UDP4OpenFail", 0},
				{"UDP6OpenFail", 0},
				{"TCP4Close", 1548268},
				{"TCP6BindFail", 0},
				{"TCP4AcceptFail", 0},
				{"UnixConn", 0},
				{"UDP4Open", 3765532},
				{"TCP6Close", 0},
				{"FDwatchRecvErr", 0},
				{"UDP4Conn", 3764828},
				{"UnixConnFail", 0},
				{"TCP6Conn", 0},
				{"TCP6OpenFail", 0},
				{"TCP6SendErr", 0},
				{"TCP6RecvErr", 0},
				{"FDwatchSendErr", 0},
				{"UDP4RecvErr", 1650},
				{"UDP4ConnFail", 0},
				{"UDP6Close", 238267},
				{"FDWatchClose", 0},
				{"TCP4Accept", 1547672},
				{"UnixAccept", 0},
				{"TCP4Open", 602},
				{"UDP4BindFail", 219},
				{"UDP6ConnFail", 238250},
				{"UnixClose", 0},
				{"TCP4BindFail", 0},
				{"UnixOpenFail", 0},
				{"UDP6BindFail", 16},
				{"UnixOpen", 0},
				{"UnixAcceptFail", 0},
				{"UnixRecvErr", 0},
				{"UDP6RecvErr", 0},
				{"TCP6ConnFail", 0},
				{"FDwatchConnFail", 0},
				{"TCP4SendErr", 0},
				{"UDP4Close", 3765528},
				{"UnixSendErr", 0},
				{"TCP6Open", 2},
				{"UDP6Conn", 1},
				{"TCP6Accept", 0},
				{"UnixBindFail", 0},
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.counterType, func(t *testing.T) {
			tags := map[string]string{
				"url":    url,
				"type":   tc.counterType,
				"source": host,
				"port":   port,
			}

			fields := map[string]interface{}{}

			for _, val := range tc.values {
				fields[val.fieldKey] = val.fieldValue
			}

			acc.AssertContainsTaggedFields(t, "bind_counter", fields, tags)
		})
	}

	// Subtest for memory stats
	t.Run("memory", func(t *testing.T) {
		tags := map[string]string{
			"url":    url,
			"source": host,
			"port":   port,
		}

		fields := map[string]interface{}{
			"block_size":   int64(77070336),
			"context_size": int64(6663840),
			"in_use":       int64(20772579),
			"lost":         int64(0),
			"total_use":    int64(81804609),
		}

		acc.AssertContainsTaggedFields(t, "bind_memory", fields, tags)
	})

	// Subtest for per-context memory stats
	t.Run("memory_context", func(t *testing.T) {
		assert.True(t, acc.HasInt64Field("bind_memory_context", "total"))
		assert.True(t, acc.HasInt64Field("bind_memory_context", "in_use"))
	})
}

func TestBindXmlStatsV3(t *testing.T) {
	ts := httptest.NewServer(http.FileServer(http.Dir("testdata")))
	url := ts.Listener.Addr().String()
	host, port, _ := net.SplitHostPort(url)
	defer ts.Close()

	b := Bind{
		Urls:                 []string{ts.URL + "/xml/v3"},
		GatherMemoryContexts: true,
		GatherViews:          true,
	}

	var acc testutil.Accumulator
	err := acc.GatherError(b.Gather)

	assert.Nil(t, err)

	// Use subtests for counters, since they are similar structure
	type fieldSet struct {
		fieldKey   string
		fieldValue int64
	}

	testCases := []struct {
		counterType string
		values      []fieldSet
	}{
		{
			"opcode",
			[]fieldSet{
				{"NOTIFY", 0},
				{"UPDATE", 0},
				{"IQUERY", 0},
				{"QUERY", 74941},
				{"STATUS", 0},
			},
		},
		{
			"qtype",
			[]fieldSet{
				{"ANY", 22},
				{"SOA", 18},
				{"AAAA", 5735},
				{"MX", 618},
				{"NS", 373},
				{"TXT", 970},
				{"A", 63672},
				{"SRV", 139},
				{"PTR", 3393},
				{"RRSIG", 1},
			},
		},
		{
			"nsstat",
			[]fieldSet{
				{"DNS64", 0},
				{"ExpireOpt", 0},
				{"NSIDOpt", 0},
				{"OtherOpt", 59},
				{"XfrReqDone", 0},
				{"ReqEdns0", 9250},
				{"ReqTSIG", 0},
				{"UpdateRespFwd", 0},
				{"RespEDNS0", 9250},
				{"QryDropped", 11},
				{"RPZRewrites", 0},
				{"XfrRej", 0},
				{"RecQryRej", 35},
				{"QryNxrrset", 2452},
				{"QryFORMERR", 0},
				{"ReqTCP", 260},
				{"QryTCP", 258},
				{"QryUDP", 74648},
				{"UpdateDone", 0},
				{"QrySERVFAIL", 122},
				{"QryRecursion", 53750},
				{"RecursClients", 0},
				{"Requestv4", 74942},
				{"UpdateFwdFail", 0},
				{"QryReferral", 0},
				{"Response", 63264},
				{"RespTSIG", 0},
				{"QrySuccess", 49044},
				{"QryFailure", 35},
				{"RespSIG0", 0},
				{"ReqSIG0", 0},
				{"UpdateRej", 0},
				{"QryAuthAns", 2752},
				{"UpdateFail", 0},
				{"QryDuplicate", 11667},
				{"RateDropped", 0},
				{"QryNoauthAns", 60354},
				{"QryNXDOMAIN", 11610},
				{"ReqBadSIG", 0},
				{"UpdateReqFwd", 0},
				{"RateSlipped", 0},
				{"TruncatedResp", 365},
				{"Requestv6", 0},
				{"UpdateBadPrereq", 0},
				{"AuthQryRej", 0},
				{"ReqBadEDNSVer", 0},
				{"SitBadSize", 0},
				{"SitBadTime", 0},
				{"SitMatch", 0},
				{"SitNew", 0},
				{"SitNoMatch", 0},
				{"SitOpt", 0},
				{"TruncatedResp", 365},
			},
		},
		{
			"sockstat",
			[]fieldSet{
				{"FDwatchConnFail", 0},
				{"UnixClose", 0},
				{"TCP6OpenFail", 0},
				{"TCP6Active", 0},
				{"UDP4RecvErr", 14},
				{"TCP6Conn", 0},
				{"FDWatchClose", 0},
				{"TCP4ConnFail", 0},
				{"UnixConn", 0},
				{"UnixSendErr", 0},
				{"UDP6Close", 0},
				{"UnixOpen", 0},
				{"UDP4Conn", 92535},
				{"TCP4Close", 336},
				{"UnixAcceptFail", 0},
				{"UnixAccept", 0},
				{"TCP6AcceptFail", 0},
				{"UDP6Open", 0},
				{"UDP6BindFail", 0},
				{"UDP6RecvErr", 0},
				{"RawOpenFail", 0},
				{"TCP4Accept", 293},
				{"UDP6SendErr", 0},
				{"UDP6Conn", 0},
				{"TCP4SendErr", 0},
				{"UDP4BindFail", 1},
				{"UDP4Active", 4},
				{"TCP4Active", 297},
				{"UnixConnFail", 0},
				{"UnixOpenFail", 0},
				{"UDP6ConnFail", 0},
				{"TCP6Accept", 0},
				{"UnixRecvErr", 0},
				{"RawActive", 1},
				{"UDP6OpenFail", 0},
				{"RawClose", 0},
				{"UnixBindFail", 0},
				{"UnixActive", 0},
				{"FdwatchBindFail", 0},
				{"UDP4SendErr", 0},
				{"RawRecvErr", 0},
				{"TCP6Close", 0},
				{"FDwatchRecvErr", 0},
				{"TCP4BindFail", 0},
				{"TCP4AcceptFail", 0},
				{"TCP4OpenFail", 0},
				{"UDP4Open", 92542},
				{"UDP4ConnFail", 0},
				{"TCP4Conn", 44},
				{"TCP6ConnFail", 0},
				{"FDwatchConn", 0},
				{"UDP6Active", 0},
				{"RawOpen", 1},
				{"TCP6BindFail", 0},
				{"UDP4Close", 92538},
				{"TCP6Open", 0},
				{"TCP6SendErr", 0},
				{"TCP4Open", 48},
				{"FDwatchSendErr", 0},
				{"TCP6RecvErr", 0},
				{"UDP4OpenFail", 0},
				{"TCP4RecvErr", 0},
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.counterType, func(t *testing.T) {
			tags := map[string]string{
				"url":    url,
				"type":   tc.counterType,
				"source": host,
				"port":   port,
			}

			fields := map[string]interface{}{}

			for _, val := range tc.values {
				fields[val.fieldKey] = val.fieldValue
			}

			acc.AssertContainsTaggedFields(t, "bind_counter", fields, tags)
		})
	}

	// Subtest for memory stats
	t.Run("memory", func(t *testing.T) {
		tags := map[string]string{
			"url":    url,
			"source": host,
			"port":   port,
		}

		fields := map[string]interface{}{
			"block_size":   int64(45875200),
			"context_size": int64(10037400),
			"in_use":       int64(6000232),
			"lost":         int64(0),
			"total_use":    int64(777821909),
		}

		acc.AssertContainsTaggedFields(t, "bind_memory", fields, tags)
	})

	// Subtest for per-context memory stats
	t.Run("memory_context", func(t *testing.T) {
		assert.True(t, acc.HasInt64Field("bind_memory_context", "total"))
		assert.True(t, acc.HasInt64Field("bind_memory_context", "in_use"))
	})
}

func TestBindUnparseableURL(t *testing.T) {
	b := Bind{
		Urls: []string{"://example.com"},
	}

	var acc testutil.Accumulator
	err := acc.GatherError(b.Gather)
	assert.Contains(t, err.Error(), "Unable to parse address")
}
