// Copyright 2013 Google Inc.  All rights reserved.
//
// Licensed 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.

package pretty

import (
	"fmt"
	"net"
	"reflect"
	"testing"
	"time"
)

func TestVal2nodeDefault(t *testing.T) {
	err := fmt.Errorf("err")
	var errNil error

	tests := []struct {
		desc string
		raw  interface{}
		want node
	}{
		{
			desc: "nil",
			raw:  nil,
			want: rawVal("nil"),
		},
		{
			desc: "nil ptr",
			raw:  (*int)(nil),
			want: rawVal("nil"),
		},
		{
			desc: "nil slice",
			raw:  []string(nil),
			want: list{},
		},
		{
			desc: "nil map",
			raw:  map[string]string(nil),
			want: keyvals{},
		},
		{
			desc: "string",
			raw:  "zaphod",
			want: stringVal("zaphod"),
		},
		{
			desc: "slice",
			raw:  []string{"a", "b"},
			want: list{stringVal("a"), stringVal("b")},
		},
		{
			desc: "map",
			raw: map[string]string{
				"zaphod": "beeblebrox",
				"ford":   "prefect",
			},
			want: keyvals{
				{"ford", stringVal("prefect")},
				{"zaphod", stringVal("beeblebrox")},
			},
		},
		{
			desc: "map of [2]int",
			raw: map[[2]int]string{
				[2]int{-1, 2}: "school",
				[2]int{0, 0}:  "origin",
				[2]int{1, 3}:  "home",
			},
			want: keyvals{
				{"[-1,2]", stringVal("school")},
				{"[0,0]", stringVal("origin")},
				{"[1,3]", stringVal("home")},
			},
		},
		{
			desc: "struct",
			raw:  struct{ Zaphod, Ford string }{"beeblebrox", "prefect"},
			want: keyvals{
				{"Zaphod", stringVal("beeblebrox")},
				{"Ford", stringVal("prefect")},
			},
		},
		{
			desc: "int",
			raw:  3,
			want: rawVal("3"),
		},
		{
			desc: "time.Time",
			raw:  time.Unix(1257894000, 0).UTC(),
			want: rawVal("2009-11-10 23:00:00 +0000 UTC"),
		},
		{
			desc: "net.IP",
			raw:  net.IPv4(127, 0, 0, 1),
			want: rawVal("127.0.0.1"),
		},
		{
			desc: "error",
			raw:  &err,
			want: rawVal("err"),
		},
		{
			desc: "nil error",
			raw:  &errNil,
			want: rawVal("<nil>"),
		},
	}

	for _, test := range tests {
		ref := &reflector{
			Config: DefaultConfig,
		}
		if got, want := ref.val2node(reflect.ValueOf(test.raw)), test.want; !reflect.DeepEqual(got, want) {
			t.Errorf("%s: got %#v, want %#v", test.desc, got, want)
		}
	}
}

func TestVal2node(t *testing.T) {
	tests := []struct {
		desc string
		raw  interface{}
		cfg  *Config
		want node
	}{
		{
			desc: "struct default",
			raw:  struct{ Zaphod, Ford, foo string }{"beeblebrox", "prefect", "BAD"},
			cfg:  DefaultConfig,
			want: keyvals{
				{"Zaphod", stringVal("beeblebrox")},
				{"Ford", stringVal("prefect")},
			},
		},
		{
			desc: "struct w/ IncludeUnexported",
			raw:  struct{ Zaphod, Ford, foo string }{"beeblebrox", "prefect", "GOOD"},
			cfg: &Config{
				IncludeUnexported: true,
			},
			want: keyvals{
				{"Zaphod", stringVal("beeblebrox")},
				{"Ford", stringVal("prefect")},
				{"foo", stringVal("GOOD")},
			},
		},
		{
			desc: "time default",
			raw:  struct{ Date time.Time }{time.Unix(1234567890, 0).UTC()},
			cfg:  DefaultConfig,
			want: keyvals{
				{"Date", rawVal("2009-02-13 23:31:30 +0000 UTC")},
			},
		},
		{
			desc: "time w/ nil Formatter",
			raw:  struct{ Date time.Time }{time.Unix(1234567890, 0).UTC()},
			cfg: &Config{
				PrintStringers: true,
				Formatter: map[reflect.Type]interface{}{
					reflect.TypeOf(time.Time{}): nil,
				},
			},
			want: keyvals{
				{"Date", keyvals{}},
			},
		},
		{
			desc: "time w/ PrintTextMarshalers",
			raw:  struct{ Date time.Time }{time.Unix(1234567890, 0).UTC()},
			cfg: &Config{
				PrintTextMarshalers: true,
			},
			want: keyvals{
				{"Date", stringVal("2009-02-13T23:31:30Z")},
			},
		},
		{
			desc: "time w/ PrintStringers",
			raw:  struct{ Date time.Time }{time.Unix(1234567890, 0).UTC()},
			cfg: &Config{
				PrintStringers: true,
			},
			want: keyvals{
				{"Date", stringVal("2009-02-13 23:31:30 +0000 UTC")},
			},
		},
		{
			desc: "circular list",
			raw:  circular(3),
			cfg:  CycleTracker,
			want: target{1, keyvals{
				{"Value", rawVal("1")},
				{"Next", keyvals{
					{"Value", rawVal("2")},
					{"Next", keyvals{
						{"Value", rawVal("3")},
						{"Next", ref{1}},
					}},
				}},
			}},
		},
		{
			desc: "self referential maps",
			raw:  selfRef(),
			cfg:  CycleTracker,
			want: target{1, keyvals{
				{"ID", rawVal("1")},
				{"Child", keyvals{
					{"2", target{2, keyvals{
						{"ID", rawVal("2")},
						{"Child", keyvals{
							{"3", target{3, keyvals{
								{"ID", rawVal("3")},
								{"Child", keyvals{
									{"1", ref{1}},
									{"2", ref{2}},
									{"3", ref{3}},
								}},
							}}},
						}},
					}}},
				}},
			}},
		},
		{
			desc: "maps of cycles",
			raw: map[string]*ListNode{
				"1. one":   circular(1),
				"2. two":   circular(2),
				"3. three": circular(1),
			},
			cfg: CycleTracker,
			want: keyvals{
				{"1. one", target{1, keyvals{
					{"Value", rawVal("1")},
					{"Next", ref{1}},
				}}},
				{"2. two", target{2, keyvals{
					{"Value", rawVal("1")},
					{"Next", keyvals{
						{"Value", rawVal("2")},
						{"Next", ref{2}},
					}},
				}}},
				{"3. three", target{3, keyvals{
					{"Value", rawVal("1")},
					{"Next", ref{3}},
				}}},
			},
		},
	}

	for _, test := range tests {
		ref := &reflector{
			Config: test.cfg,
		}
		if test.cfg.TrackCycles {
			ref.pointerTracker = new(pointerTracker)
		}
		if got, want := ref.val2node(reflect.ValueOf(test.raw)), test.want; !reflect.DeepEqual(got, want) {
			t.Run(test.desc, func(t *testing.T) {
				t.Errorf(" got %#v", got)
				t.Errorf("want %#v", want)
				t.Errorf("Diff: (-got +want)\n%s", Compare(got, want))
			})
		}
	}
}

type ListNode struct {
	Value int
	Next  *ListNode
}

func circular(nodes int) *ListNode {
	final := &ListNode{
		Value: nodes,
	}
	final.Next = final

	recent := final
	for i := nodes - 1; i > 0; i-- {
		n := &ListNode{
			Value: i,
			Next:  recent,
		}
		final.Next = n
		recent = n
	}
	return recent
}

type SelfReferential struct {
	ID    int
	Child map[int]*SelfReferential
}

func selfRef() *SelfReferential {
	sr1 := &SelfReferential{
		ID:    1,
		Child: make(map[int]*SelfReferential),
	}
	sr2 := &SelfReferential{
		ID:    2,
		Child: make(map[int]*SelfReferential),
	}
	sr3 := &SelfReferential{
		ID:    3,
		Child: make(map[int]*SelfReferential),
	}

	// Build a cycle
	sr1.Child[2] = sr2
	sr2.Child[3] = sr3
	sr3.Child[1] = sr1

	// Throw in some other stuff for funzies
	sr3.Child[2] = sr2
	sr3.Child[3] = sr3
	return sr1
}

func BenchmarkVal2node(b *testing.B) {
	benchmarks := []struct {
		desc string
		cfg  *Config
		raw  interface{}
	}{
		{
			desc: "struct",
			cfg:  DefaultConfig,
			raw:  struct{ Zaphod, Ford string }{"beeblebrox", "prefect"},
		},
		{
			desc: "map",
			cfg:  DefaultConfig,
			raw: map[[2]int]string{
				[2]int{-1, 2}: "school",
				[2]int{0, 0}:  "origin",
				[2]int{1, 3}:  "home",
			},
		},
		{
			desc: "track/struct",
			cfg:  CycleTracker,
			raw:  struct{ Zaphod, Ford string }{"beeblebrox", "prefect"},
		},
		{
			desc: "track/map",
			cfg:  CycleTracker,
			raw: map[[2]int]string{
				[2]int{-1, 2}: "school",
				[2]int{0, 0}:  "origin",
				[2]int{1, 3}:  "home",
			},
		},
		{
			desc: "circlist/small",
			cfg:  CycleTracker,
			raw:  circular(3),
		},
		{
			desc: "circlist/med",
			cfg:  CycleTracker,
			raw:  circular(300),
		},
		{
			desc: "circlist/large",
			cfg:  CycleTracker,
			raw:  circular(3000),
		},
		{
			desc: "mapofcirc/small",
			cfg:  CycleTracker,
			raw: map[string]*ListNode{
				"1. one":   circular(1),
				"2. two":   circular(2),
				"3. three": circular(1),
			},
		},
		{
			desc: "selfrefmap/small",
			cfg:  CycleTracker,
			raw:  selfRef,
		},
	}

	for _, bench := range benchmarks {
		b.Run(bench.desc, func(b *testing.B) {
			b.ReportAllocs()
			for i := 0; i < b.N; i++ {
				ref := &reflector{
					Config: bench.cfg,
				}
				if bench.cfg.TrackCycles {
					ref.pointerTracker = new(pointerTracker)
				}
				ref.val2node(reflect.ValueOf(bench.raw))
			}
		})
	}
}