// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package naming

import (
	"net"
	"reflect"
	"testing"
)

func TestEndpoint(t *testing.T) {
	defver := DefaultEndpointVersion
	defer func() {
		DefaultEndpointVersion = defver
	}()
	v6a := Endpoint{
		Protocol:         UnknownProtocol,
		Address:          "batman.com:1234",
		RoutingID:        FixedRoutingID(0xdabbad00),
		ServesMountTable: true,
	}
	v6b := Endpoint{
		Protocol:         UnknownProtocol,
		Address:          "batman.com:2345",
		RoutingID:        FixedRoutingID(0xdabbad00),
		ServesMountTable: false,
	}
	v6c := Endpoint{
		Protocol:         "tcp",
		Address:          "batman.com:2345",
		RoutingID:        FixedRoutingID(0x0),
		ServesMountTable: false,
	}
	v6d := Endpoint{
		Protocol:         "ws6",
		Address:          "batman.com:2345",
		RoutingID:        FixedRoutingID(0x0),
		ServesMountTable: false,
	}
	v6e := Endpoint{
		Protocol:         "tcp",
		Address:          "batman.com:2345",
		RoutingID:        FixedRoutingID(0xba77),
		routes:           []string{"1"},
		ServesMountTable: true,
		blessingNames:    []string{"dev.v.io:foo@bar.com", "dev.v.io:bar@bar.com:delegate"},
	}
	v6f := Endpoint{
		Protocol:         "tcp",
		Address:          "batman.com:2345",
		routes:           []string{"1", "2", "3"},
		RoutingID:        FixedRoutingID(0xba77),
		ServesMountTable: true,
		// Blessings that look similar to other parts of the endpoint.
		blessingNames: []string{"@@", "@s", "@m"},
	}
	v6g := Endpoint{
		Protocol: "tcp",
		Address:  "batman.com:2345",
		// Routes that have commas should be escaped correctly
		routes:           []string{"a,b", ",ab", "ab,"},
		RoutingID:        FixedRoutingID(0xba77),
		ServesMountTable: true,
	}

	testcasesA := []struct {
		endpoint Endpoint
		address  string
	}{
		{v6a, "batman.com:1234"},
		{v6b, "batman.com:2345"},
		{v6c, "batman.com:2345"},
	}
	for _, test := range testcasesA {
		addr := test.endpoint.Addr()
		if addr.String() != test.address {
			t.Errorf("unexpected address %q, not %q", addr.String(), test.address)
		}
	}

	// Test v6 endpoints.
	testcasesC := []struct {
		Endpoint Endpoint
		String   string
		Version  int
	}{
		{v6a, "@6@@batman.com:1234@@000000000000000000000000dabbad00@m@@@", 6},
		{v6b, "@6@@batman.com:2345@@000000000000000000000000dabbad00@s@@@", 6},
		{v6c, "@6@tcp@batman.com:2345@@00000000000000000000000000000000@s@@@", 6},
		{v6d, "@6@ws6@batman.com:2345@@00000000000000000000000000000000@s@@@", 6},
		{v6e, "@6@tcp@batman.com:2345@1@0000000000000000000000000000ba77@m@dev.v.io:foo@bar.com,dev.v.io:bar@bar.com:delegate@@", 6},
		{v6f, "@6@tcp@batman.com:2345@1,2,3@0000000000000000000000000000ba77@m@@@,@s,@m@@", 6},
		{v6g, "@6@tcp@batman.com:2345@a%2Cb,%2Cab,ab%2C@0000000000000000000000000000ba77@m@@@", 6},
	}

	for i, test := range testcasesC {
		if got, want := test.Endpoint.VersionedString(test.Version), test.String; got != want {
			t.Errorf("Test %d: Got %q want %q for endpoint (v%d): %#v", i, got, want, test.Version, test.Endpoint)
		}
		ep, err := ParseEndpoint(test.String)
		if err != nil {
			t.Errorf("Test %d: NewEndpoint(%q) failed with %v", i, test.String, err)
			continue
		}
		if !reflect.DeepEqual(ep, test.Endpoint) {
			t.Errorf("Test %d: Got endpoint %#v, want %#v for string %q", i, ep, test.Endpoint, test.String)
		}
	}
}

type endpointTest struct {
	input, output string
	err           error
}

func runEndpointTests(t *testing.T, testcases []endpointTest) {
	for _, test := range testcases {
		ep, err := ParseEndpoint(test.input)
		if err == nil && test.err == nil && ep.String() != test.output {
			t.Errorf("NewEndpoint(%q): unexpected endpoint string %q != %q",
				test.input, ep.String(), test.output)
			continue
		}
		switch {
		case test.err == err: // do nothing
		case test.err == nil && err != nil:
			t.Errorf("NewEndpoint(%q): unexpected error %q", test.output, err)
		case test.err != nil && err == nil:
			t.Errorf("NewEndpoint(%q): missing error %q", test.output, test.err)
		case err.Error() != test.err.Error():
			t.Errorf("NewEndpoint(%q): unexpected error  %q != %q", test.output, err, test.err)
		}
	}
}

func TestHostPortEndpoint(t *testing.T) {
	defver := DefaultEndpointVersion
	defer func() {
		DefaultEndpointVersion = defver
	}()
	DefaultEndpointVersion = 6
	testcases := []endpointTest{
		{"localhost:10", "@6@@localhost:10@@00000000000000000000000000000000@m@@@", nil},
		{"localhost:", "@6@@localhost:@@00000000000000000000000000000000@m@@@", nil},
		{"localhost", "", errInvalidEndpointString},
		{"(dev.v.io:service:mounttabled)@ns.dev.v.io:8101", "@6@@ns.dev.v.io:8101@@00000000000000000000000000000000@m@dev.v.io:service:mounttabled@@", nil},
		{"(dev.v.io:users:foo@bar.com)@ns.dev.v.io:8101", "@6@@ns.dev.v.io:8101@@00000000000000000000000000000000@m@dev.v.io:users:foo@bar.com@@", nil},
		{"(@1@tcp)@ns.dev.v.io:8101", "@6@@ns.dev.v.io:8101@@00000000000000000000000000000000@m@@1@tcp@@", nil},
	}
	runEndpointTests(t, testcases)
}

func TestParseHostPort(t *testing.T) {
	dns := Endpoint{
		Protocol:         "tcp",
		Address:          "batman.com:4444",
		ServesMountTable: true,
	}
	ipv4 := Endpoint{
		Protocol:         "tcp",
		Address:          "192.168.1.1:4444",
		ServesMountTable: true,
	}
	ipv6 := Endpoint{
		Protocol:         "tcp",
		Address:          "[01:02::]:4444",
		ServesMountTable: true,
	}
	testcases := []struct {
		Endpoint   Endpoint
		Host, Port string
	}{
		{dns, "batman.com", "4444"},
		{ipv4, "192.168.1.1", "4444"},
		{ipv6, "01:02::", "4444"},
	}

	for _, test := range testcases {
		addr := net.JoinHostPort(test.Host, test.Port)
		epString := FormatEndpoint("tcp", addr)
		if ep, err := ParseEndpoint(epString); err != nil {
			t.Errorf("NewEndpoint(%q) failed with %v", addr, err)
		} else {
			if !reflect.DeepEqual(test.Endpoint, ep) {
				t.Errorf("Got endpoint %T = %#v, want %T = %#v for string %q", ep, ep, test.Endpoint, test.Endpoint, addr)
			}
		}
	}
}

func TestEscapeEndpoint(t *testing.T) {
	defver := DefaultEndpointVersion
	defer func() {
		DefaultEndpointVersion = defver
	}()
	testcases := []Endpoint{
		Endpoint{Protocol: "unix", Address: "@", RoutingID: FixedRoutingID(0xdabbad00)},
		Endpoint{Protocol: "unix", Address: "@/%", RoutingID: FixedRoutingID(0xdabbad00)},
	}
	for i, ep := range testcases {
		epstr := ep.String()
		got, err := ParseEndpoint(epstr)
		if err != nil {
			t.Errorf("Test %d: NewEndpoint(%q) failed with %v", i, epstr, err)
			continue
		}
		if !reflect.DeepEqual(ep, got) {
			t.Errorf("Test %d: Got endpoint %#v, want %#v", i, got, ep)
		}
	}
}