package manager

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import (
	"reflect"
	"testing"

	"github.com/apache/trafficcontrol/lib/go-tc"
)

func TestCreateServerHealthPollURL(t *testing.T) {
	tmpl := `http://${hostname}/_astats?application=&inf.name=${interface_name}`
	srv := tc.TrafficServer{
		Interfaces: []tc.ServerInterfaceInfo{
			{
				IPAddresses: []tc.ServerIPAddress{
					{
						Address:        "192.0.2.42",
						Gateway:        nil,
						ServiceAddress: true,
					},
					{
						Address:        "1::3:3:7",
						Gateway:        nil,
						ServiceAddress: true,
					},
				},
				MaxBandwidth: nil,
				MTU:          nil,
				Monitor:      true,
				Name:         "george",
			},
		},
	}

	expectedV4 := "http://192.0.2.42/_astats?application=system&inf.name=george"
	expectedV6 := "http://[1::3:3:7]/_astats?application=system&inf.name=george"
	actualV4, actualV6 := createServerHealthPollURLs(tmpl, srv)

	if expectedV4 != actualV4 {
		t.Errorf("incorrect IPv4 polling URL; expected: '%s', actual: '%s'", expectedV4, actualV4)
	}

	if expectedV6 != actualV6 {
		t.Errorf("incorrect IPv6 polling URL; expected: '%s', actual: '%s'", expectedV6, actualV6)
	}
}

func TestCreateServerHealthPollURLTemplatePort(t *testing.T) {
	tmpl := "http://${hostname}:1234/_astats?application=&inf.name=${interface_name}"
	srv := tc.TrafficServer{
		Interfaces: []tc.ServerInterfaceInfo{
			{
				IPAddresses: []tc.ServerIPAddress{
					{
						Address:        "192.0.2.42",
						Gateway:        nil,
						ServiceAddress: true,
					},
					{
						Address:        "1::3:3:7",
						Gateway:        nil,
						ServiceAddress: true,
					},
				},
				MaxBandwidth: nil,
				MTU:          nil,
				Monitor:      true,
				Name:         "george",
			},
		},
		Port: 1234,
	}

	expectedV4 := "http://192.0.2.42:1234/_astats?application=system&inf.name=george"
	expectedV6 := "http://[1::3:3:7]:1234/_astats?application=system&inf.name=george"
	actualV4, actualV6 := createServerHealthPollURLs(tmpl, srv)

	if expectedV4 != actualV4 {
		t.Errorf("incorrect IPv4 polling URL; expected: '%s', actual: '%s'", expectedV4, actualV4)
	}

	if expectedV6 != actualV6 {
		t.Errorf("incorrect IPv6 polling URL; expected: '%s', actual: '%s'", expectedV6, actualV6)
	}
}

func TestCreateServerHealthPollURLServerPort(t *testing.T) {
	tmpl := "http://${hostname}/_astats?application=&inf.name=${interface_name}"
	srv := tc.TrafficServer{
		HTTPSPort: 910,
		Interfaces: []tc.ServerInterfaceInfo{
			{
				IPAddresses: []tc.ServerIPAddress{
					{
						Address:        "192.0.2.42",
						Gateway:        nil,
						ServiceAddress: true,
					},
					{
						Address:        "1::3:3:7",
						Gateway:        nil,
						ServiceAddress: true,
					},
				},
				MaxBandwidth: nil,
				MTU:          nil,
				Monitor:      true,
				Name:         "george",
			},
		},
		Port: 5678,
	}

	expectedV4 := "http://192.0.2.42:5678/_astats?application=system&inf.name=george"
	expectedV6 := "http://[1::3:3:7]:5678/_astats?application=system&inf.name=george"
	actualV4, actualV6 := createServerHealthPollURLs(tmpl, srv)

	if expectedV4 != actualV4 {
		t.Errorf("incorrect IPv4 polling URL; expected: '%s', actual: '%s'", expectedV4, actualV4)
	}

	if expectedV6 != actualV6 {
		t.Errorf("incorrect IPv6 polling URL; expected: '%s', actual: '%s'", expectedV6, actualV6)
	}

}

func TestCreateServerHealthPollURLServerPortHTTPS(t *testing.T) {
	tmpl := "hTTps://${hostname}/_astats?application=&inf.name=${interface_name}"
	srv := tc.TrafficServer{
		HTTPSPort: 910,
		Interfaces: []tc.ServerInterfaceInfo{
			{
				IPAddresses: []tc.ServerIPAddress{
					{
						Address:        "192.0.2.42",
						Gateway:        nil,
						ServiceAddress: true,
					},
					{
						Address:        "1::3:3:7",
						Gateway:        nil,
						ServiceAddress: true,
					},
				},
				MaxBandwidth: nil,
				MTU:          nil,
				Monitor:      true,
				Name:         "george",
			},
		},
		Port: 5678,
	}

	expectedV4 := "https://192.0.2.42:910/_astats?application=system&inf.name=george"
	expectedV6 := "https://[1::3:3:7]:910/_astats?application=system&inf.name=george"
	actualV4, actualV6 := createServerHealthPollURLs(tmpl, srv)

	if expectedV4 != actualV4 {
		t.Errorf("incorrect IPv4 polling URL; expected: '%s', actual: '%s'", expectedV4, actualV4)
	}

	if expectedV6 != actualV6 {
		t.Errorf("incorrect IPv6 polling URL; expected: '%s', actual: '%s'", expectedV6, actualV6)
	}
}

func TestCreateServerHealthPollURLTemplateAndServerPort(t *testing.T) {

	// if both template and server ports exist, template takes precedence

	tmpl := "http://${hostname}:1234/_astats?application=&inf.name=${interface_name}"
	srv := tc.TrafficServer{
		HTTPSPort: 910,
		Interfaces: []tc.ServerInterfaceInfo{
			{
				IPAddresses: []tc.ServerIPAddress{
					{
						Address:        "192.0.2.42",
						Gateway:        nil,
						ServiceAddress: true,
					},
					{
						Address:        "1::3:3:7",
						Gateway:        nil,
						ServiceAddress: true,
					},
				},
				MaxBandwidth: nil,
				MTU:          nil,
				Monitor:      true,
				Name:         "george",
			},
		},
		Port: 5678,
	}

	expectedV4 := "http://192.0.2.42:1234/_astats?application=system&inf.name=george"
	expectedV6 := "http://[1::3:3:7]:1234/_astats?application=system&inf.name=george"
	actualV4, actualV6 := createServerHealthPollURLs(tmpl, srv)

	if expectedV4 != actualV4 {
		t.Errorf("incorrect IPv4 polling URL; expected: '%s', actual: '%s'", expectedV4, actualV4)
	}

	if expectedV6 != actualV6 {
		t.Errorf("incorrect IPv6 polling URL; expected: '%s', actual: '%s'", expectedV6, actualV6)
	}
}

func TestCreateServerStatPollURL(t *testing.T) {
	tmpl := `http://${hostname}/_astats?application=&inf.name=${interface_name}`
	srv := tc.TrafficServer{
		Interfaces: []tc.ServerInterfaceInfo{
			{
				IPAddresses: []tc.ServerIPAddress{
					{
						Address:        "192.0.2.42",
						Gateway:        nil,
						ServiceAddress: true,
					},
					{
						Address:        "1::3:3:7",
						Gateway:        nil,
						ServiceAddress: true,
					},
				},
				MaxBandwidth: nil,
				MTU:          nil,
				Monitor:      true,
				Name:         "george",
			},
		},
	}

	expectedV4 := "http://192.0.2.42/_astats?application=&inf.name=george"
	expectedV6 := "http://[1::3:3:7]/_astats?application=&inf.name=george"

	healthV4, healthV6 := createServerHealthPollURLs(tmpl, srv)
	actualV4 := createServerStatPollURL(healthV4)
	actualV6 := createServerStatPollURL(healthV6)

	if expectedV4 != actualV4 {
		t.Errorf("incorrect IPv4 polling URL; expected: '%s', actual: '%s'", expectedV4, actualV4)
	}

	if expectedV6 != actualV6 {
		t.Errorf("incorrect IPv6 polling URL; expected: '%s', actual: '%s'", expectedV6, actualV6)
	}
}

func TestGetCacheGroupsToPoll(t *testing.T) {
	monitors := map[string]tc.TrafficMonitor{
		"tm2": {
			HostName:     "tm2",
			Location:     "tm-group-2",
			ServerStatus: "ONLINE",
		},
		"tm1": {
			HostName:     "tm1",
			Location:     "tm-group-1",
			ServerStatus: "ONLINE",
		},
		"tm3": {
			HostName:     "tm3",
			Location:     "tm-group-3",
			ServerStatus: "ONLINE",
		},
	}
	caches := map[string]tc.TrafficServer{
		"cache2": {
			CacheGroup:   "cache-group-2",
			ServerStatus: "REPORTED",
		},
		"cache1": {
			CacheGroup:   "cache-group-1",
			ServerStatus: "REPORTED",
		},
		"cache3": {
			CacheGroup:   "cache-group-3",
			ServerStatus: "REPORTED",
		},
	}
	cacheGroups := map[string]tc.TMCacheGroup{
		"tm-group-2": {
			Name: "tm-group-2",
			Coordinates: tc.MonitoringCoordinates{
				Latitude:  38.39,
				Longitude: -99.58,
			},
		},
		"tm-group-1": {
			Name: "tm-group-1",
			Coordinates: tc.MonitoringCoordinates{
				Latitude:  37.32,
				Longitude: -121.34,
			},
		},
		"tm-group-3": {
			Name: "tm-group-3",
			Coordinates: tc.MonitoringCoordinates{
				Latitude:  37.22,
				Longitude: -77.53,
			},
		},
		"cache-group-3": {
			Name: "cache-group-3",
			Coordinates: tc.MonitoringCoordinates{
				Latitude:  41.93,
				Longitude: -74.17,
			},
		},
		"cache-group-1": {
			Name: "cache-group-1",
			Coordinates: tc.MonitoringCoordinates{
				Latitude:  35.04,
				Longitude: -120.12,
			},
		},
		"cache-group-2": {
			Name: "cache-group-2",
			Coordinates: tc.MonitoringCoordinates{
				Latitude:  40.92,
				Longitude: -98.49,
			},
		},
	}
	type testCase struct {
		DistributedPolling bool
		TMName             string
		ExpectedTMGroup    string
		ExpectedToPoll     map[string]tc.TMCacheGroup
		ExpectErr          bool
	}

	for _, tc := range []testCase{
		{
			DistributedPolling: true,
			TMName:             "tm1",
			ExpectedTMGroup:    "tm-group-1",
			ExpectedToPoll: map[string]tc.TMCacheGroup{
				"cache-group-1": cacheGroups["cache-group-1"],
			},
			ExpectErr: false,
		},
		{
			DistributedPolling: true,
			TMName:             "tm2",
			ExpectedTMGroup:    "tm-group-2",
			ExpectedToPoll: map[string]tc.TMCacheGroup{
				"cache-group-2": cacheGroups["cache-group-2"],
			},
			ExpectErr: false,
		},
		{
			DistributedPolling: true,
			TMName:             "tm3",
			ExpectedTMGroup:    "tm-group-3",
			ExpectedToPoll: map[string]tc.TMCacheGroup{
				"cache-group-3": cacheGroups["cache-group-3"],
			},
			ExpectErr: false,
		},
		{
			DistributedPolling: false,
			TMName:             "tm3",
			ExpectedTMGroup:    "tm-group-3",
			ExpectedToPoll: map[string]tc.TMCacheGroup{
				"cache-group-1": cacheGroups["cache-group-1"],
				"cache-group-2": cacheGroups["cache-group-2"],
				"cache-group-3": cacheGroups["cache-group-3"],
			},
			ExpectErr: false,
		},
	} {
		tmGroup, tmStatus, toPoll, err := getCacheGroupsToPoll(tc.DistributedPolling, tc.TMName, monitors, caches, cacheGroups)
		if tc.ExpectErr != (err != nil) {
			t.Errorf("getting cachegroups to poll -- expect error: %t, actual error: %v", tc.ExpectErr, err)
		}
		if tc.ExpectedTMGroup != tmGroup {
			t.Errorf("getting TM group -- expected: %s, actual: %s", tc.ExpectedTMGroup, tmGroup)
		}
		if tmStatus != "ONLINE" {
			t.Errorf("expected TM status: ONLINE, actual: %s", tmStatus)
		}
		if !reflect.DeepEqual(tc.ExpectedToPoll, toPoll) {
			t.Errorf("getting cachegroups to poll -- expected: %+v, actual: %+v", tc.ExpectedToPoll, toPoll)
		}
	}
}