package gg

import (
	"fmt"
	"sort"
	"strings"
	. "testing"

	"github.com/stretchr/testify/assert"
)

func edge(val Value, from *Vertex) Edge {
	return Edge{Value: val, From: from}
}

func value(val Value, in ...Edge) *Vertex {
	return &Vertex{
		VertexType: ValueVertex,
		Value:      val,
		In:         in,
	}
}

func tuple(val Value, in ...Edge) Edge {
	return Edge{
		From: &Vertex{
			VertexType: TupleVertex,
			In:         in,
		},
		Value: val,
	}
}

func assertVertexEqual(t *T, exp, got *Vertex, msgAndArgs ...interface{}) bool {
	var assertInner func(*Vertex, *Vertex, map[*Vertex]bool) bool
	assertInner = func(exp, got *Vertex, m map[*Vertex]bool) bool {
		// if got is already in m then we've already looked at it
		if m[got] {
			return true
		}
		m[got] = true

		assert.Equal(t, exp.VertexType, got.VertexType, msgAndArgs...)
		assert.Equal(t, exp.Value, got.Value, msgAndArgs...)
		if !assert.Len(t, got.In, len(exp.In), msgAndArgs...) {
			return false
		}
		for i := range exp.In {
			assertInner(exp.In[i].From, got.In[i].From, m)
			assert.Equal(t, exp.In[i].Value, got.In[i].Value, msgAndArgs...)
			assert.Equal(t, got, got.In[i].To)
			assert.Contains(t, got.In[i].From.Out, got.In[i])
		}
		return true

	}
	return assertInner(exp, got, map[*Vertex]bool{})
}

func assertIter(t *T, expVals, expJuncs int, g *Graph, msgAndArgs ...interface{}) {
	seen := map[*Vertex]bool{}
	var gotVals, gotJuncs int
	g.Iter(func(v *Vertex) bool {
		assert.NotContains(t, seen, v, msgAndArgs...)
		seen[v] = true
		if v.VertexType == ValueVertex {
			gotVals++
		} else {
			gotJuncs++
		}
		return true
	})
	assert.Equal(t, expVals, gotVals, msgAndArgs...)
	assert.Equal(t, expJuncs, gotJuncs, msgAndArgs...)
}

type graphTest struct {
	name              string
	out               func() *Graph
	exp               []*Vertex
	numVals, numJuncs int
}

func mkTest(name string, out func() *Graph, numVals, numJuncs int, exp ...*Vertex) graphTest {
	return graphTest{
		name:    name,
		out:     out,
		exp:     exp,
		numVals: numVals, numJuncs: numJuncs,
	}
}

func TestGraph(t *T) {
	var (
		v0  = NewValue("v0")
		v1  = NewValue("v1")
		v2  = NewValue("v2")
		v3  = NewValue("v3")
		e0  = NewValue("e0")
		e00 = NewValue("e00")
		e01 = NewValue("e01")
		e1  = NewValue("e1")
		e10 = NewValue("e10")
		e11 = NewValue("e11")
		e2  = NewValue("e2")
		e20 = NewValue("e20")
		e21 = NewValue("e21")
		ej0 = NewValue("ej0")
		ej1 = NewValue("ej1")
		ej2 = NewValue("ej2")
	)
	tests := []graphTest{
		mkTest(
			"values-basic",
			func() *Graph {
				return ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
			},
			2, 0,
			value(v0),
			value(v1, edge(e0, value(v0))),
		),

		mkTest(
			"values-2edges",
			func() *Graph {
				g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v2)
				return g0.AddValueIn(ValueOut(v1, e1), v2)
			},
			3, 0,
			value(v0),
			value(v1),
			value(v2,
				edge(e0, value(v0)),
				edge(e1, value(v1)),
			),
		),

		mkTest(
			"values-separate",
			func() *Graph {
				g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
				return g0.AddValueIn(ValueOut(v2, e2), v3)
			},
			4, 0,
			value(v0),
			value(v1, edge(e0, value(v0))),
			value(v2),
			value(v3, edge(e2, value(v2))),
		),

		mkTest(
			"values-circular",
			func() *Graph {
				return ZeroGraph.AddValueIn(ValueOut(v0, e0), v0)
			},
			1, 0,
			value(v0, edge(e0, value(v0))),
		),

		mkTest(
			"values-circular2",
			func() *Graph {
				g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
				return g0.AddValueIn(ValueOut(v1, e1), v0)
			},
			2, 0,
			value(v0, edge(e1, value(v1, edge(e0, value(v0))))),
			value(v1, edge(e0, value(v0, edge(e1, value(v1))))),
		),

		mkTest(
			"values-circular3",
			func() *Graph {
				g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
				g1 := g0.AddValueIn(ValueOut(v1, e1), v2)
				return g1.AddValueIn(ValueOut(v2, e2), v1)
			},
			3, 0,
			value(v0),
			value(v1,
				edge(e0, value(v0)),
				edge(e2, value(v2, edge(e1, value(v1)))),
			),
			value(v2, edge(e1, value(v1,
				edge(e0, value(v0)),
				edge(e2, value(v2)),
			))),
		),

		mkTest(
			"tuple-basic",
			func() *Graph {
				e0 := ValueOut(v0, e0)
				e1 := ValueOut(v1, e1)
				ej0 := TupleOut([]OpenEdge{e0, e1}, ej0)
				return ZeroGraph.AddValueIn(ej0, v2)
			},
			3, 1,
			value(v0), value(v1),
			value(v2, tuple(ej0,
				edge(e0, value(v0)),
				edge(e1, value(v1)),
			)),
		),

		mkTest(
			"tuple-basic2",
			func() *Graph {
				e00 := ValueOut(v0, e00)
				e10 := ValueOut(v1, e10)
				ej0 := TupleOut([]OpenEdge{e00, e10}, ej0)
				e01 := ValueOut(v0, e01)
				e11 := ValueOut(v1, e11)
				ej1 := TupleOut([]OpenEdge{e01, e11}, ej1)
				ej2 := TupleOut([]OpenEdge{ej0, ej1}, ej2)
				return ZeroGraph.AddValueIn(ej2, v2)
			},
			3, 3,
			value(v0), value(v1),
			value(v2, tuple(ej2,
				tuple(ej0,
					edge(e00, value(v0)),
					edge(e10, value(v1)),
				),
				tuple(ej1,
					edge(e01, value(v0)),
					edge(e11, value(v1)),
				),
			)),
		),

		mkTest(
			"tuple-circular",
			func() *Graph {
				e0 := ValueOut(v0, e0)
				e1 := ValueOut(v1, e1)
				ej0 := TupleOut([]OpenEdge{e0, e1}, ej0)
				g0 := ZeroGraph.AddValueIn(ej0, v2)
				e20 := ValueOut(v2, e20)
				g1 := g0.AddValueIn(e20, v0)
				e21 := ValueOut(v2, e21)
				return g1.AddValueIn(e21, v1)
			},
			3, 1,
			value(v0, edge(e20, value(v2, tuple(ej0,
				edge(e0, value(v0)),
				edge(e1, value(v1, edge(e21, value(v2)))),
			)))),
			value(v1, edge(e21, value(v2, tuple(ej0,
				edge(e0, value(v0, edge(e20, value(v2)))),
				edge(e1, value(v1)),
			)))),
			value(v2, tuple(ej0,
				edge(e0, value(v0, edge(e20, value(v2)))),
				edge(e1, value(v1, edge(e21, value(v2)))),
			)),
		),
	}

	for i := range tests {
		t.Logf("test[%d]:%q", i, tests[i].name)
		out := tests[i].out()
		for j, exp := range tests[i].exp {
			msgAndArgs := []interface{}{
				"tests[%d].name:%q exp[%d].val:%q",
				i, tests[i].name, j, exp.Value.V.(string),
			}
			v := out.ValueVertex(exp.Value)
			if !assert.NotNil(t, v, msgAndArgs...) {
				continue
			}
			assertVertexEqual(t, exp, v, msgAndArgs...)
		}

		msgAndArgs := []interface{}{
			"tests[%d].name:%q",
			i, tests[i].name,
		}

		// sanity check that graphs are equal to themselves
		assert.True(t, Equal(out, out), msgAndArgs...)

		// test the Iter method in here too
		assertIter(t, tests[i].numVals, tests[i].numJuncs, out, msgAndArgs...)
	}
}

func TestGraphImmutability(t *T) {
	v0 := NewValue("v0")
	v1 := NewValue("v1")
	e0 := NewValue("e0")
	oe0 := ValueOut(v0, e0)
	g0 := ZeroGraph.AddValueIn(oe0, v1)
	assert.Nil(t, ZeroGraph.ValueVertex(v0))
	assert.Nil(t, ZeroGraph.ValueVertex(v1))
	assert.NotNil(t, g0.ValueVertex(v0))
	assert.NotNil(t, g0.ValueVertex(v1))

	// half-edges should be re-usable
	v2 := NewValue("v2")
	v3a, v3b := NewValue("v3a"), NewValue("v3b")
	e1 := NewValue("e1")
	oe1 := ValueOut(v2, e1)
	g1a := g0.AddValueIn(oe1, v3a)
	g1b := g0.AddValueIn(oe1, v3b)
	assertVertexEqual(t, value(v3a, edge(e1, value(v2))), g1a.ValueVertex(v3a))
	assert.Nil(t, g1a.ValueVertex(v3b))
	assertVertexEqual(t, value(v3b, edge(e1, value(v2))), g1b.ValueVertex(v3b))
	assert.Nil(t, g1b.ValueVertex(v3a))

	// ... even re-usable twice in succession
	v3 := NewValue("v3")
	v4 := NewValue("v4")
	g2 := g0.AddValueIn(oe1, v3).AddValueIn(oe1, v4)
	assert.Nil(t, g2.ValueVertex(v3b))
	assert.Nil(t, g2.ValueVertex(v3a))
	assertVertexEqual(t, value(v3, edge(e1, value(v2))), g2.ValueVertex(v3))
	assertVertexEqual(t, value(v4, edge(e1, value(v2))), g2.ValueVertex(v4))
}

func TestGraphDelValueIn(t *T) {
	v0 := NewValue("v0")
	v1 := NewValue("v1")
	e0 := NewValue("e0")
	{ // removing from null
		g := ZeroGraph.DelValueIn(ValueOut(v0, e0), v1)
		assert.True(t, Equal(ZeroGraph, g))
	}

	e1 := NewValue("e1")
	{ // removing edge from vertex which doesn't have that edge
		g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
		g1 := g0.DelValueIn(ValueOut(v0, e1), v1)
		assert.True(t, Equal(g0, g1))
	}

	{ // removing only edge
		oe := ValueOut(v0, e0)
		g0 := ZeroGraph.AddValueIn(oe, v1)
		g1 := g0.DelValueIn(oe, v1)
		assert.True(t, Equal(ZeroGraph, g1))
	}

	ej0 := NewValue("ej0")
	v2 := NewValue("v2")
	{ // removing only edge (tuple)
		oe := TupleOut([]OpenEdge{
			ValueOut(v0, e0),
			ValueOut(v1, e1),
		}, ej0)
		g0 := ZeroGraph.AddValueIn(oe, v2)
		g1 := g0.DelValueIn(oe, v2)
		assert.True(t, Equal(ZeroGraph, g1))
	}

	{ // removing one of two edges
		oe := ValueOut(v1, e0)
		g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v2)
		g1 := g0.AddValueIn(oe, v2)
		g2 := g1.DelValueIn(oe, v2)
		assert.True(t, Equal(g0, g2))
		assert.NotNil(t, g2.ValueVertex(v0))
		assert.Nil(t, g2.ValueVertex(v1))
		assert.NotNil(t, g2.ValueVertex(v2))
	}

	e2 := NewValue("e2")
	eja, ejb := NewValue("eja"), NewValue("ejb")
	v3 := NewValue("v3")
	{ // removing one of two edges (tuple)
		e0 := ValueOut(v0, e0)
		e1 := ValueOut(v1, e1)
		e2 := ValueOut(v2, e2)
		oeA := TupleOut([]OpenEdge{e0, e1}, eja)
		oeB := TupleOut([]OpenEdge{e1, e2}, ejb)
		g0a := ZeroGraph.AddValueIn(oeA, v3)
		g0b := ZeroGraph.AddValueIn(oeB, v3)
		g1 := g0a.Union(g0b).DelValueIn(oeA, v3)
		assert.True(t, Equal(g1, g0b))
		assert.Nil(t, g1.ValueVertex(v0))
		assert.NotNil(t, g1.ValueVertex(v1))
		assert.NotNil(t, g1.ValueVertex(v2))
		assert.NotNil(t, g1.ValueVertex(v3))
	}

	{ // removing one of two edges in circular graph
		e0 := ValueOut(v0, e0)
		e1 := ValueOut(v1, e1)
		g0 := ZeroGraph.AddValueIn(e0, v1).AddValueIn(e1, v0)
		g1 := g0.DelValueIn(e0, v1)
		assert.True(t, Equal(ZeroGraph.AddValueIn(e1, v0), g1))
		assert.NotNil(t, g1.ValueVertex(v0))
		assert.NotNil(t, g1.ValueVertex(v1))
	}

	ej := NewValue("ej")
	{ // removing to's only edge, sub-nodes have edge to each other
		oej := TupleOut([]OpenEdge{
			ValueOut(v0, ej0),
			ValueOut(v1, ej0),
		}, ej)
		g0 := ZeroGraph.AddValueIn(oej, v2)
		e0 := ValueOut(v0, e0)
		g1 := g0.AddValueIn(e0, v1)
		g2 := g1.DelValueIn(oej, v2)
		assert.True(t, Equal(ZeroGraph.AddValueIn(e0, v1), g2))
		assert.NotNil(t, g2.ValueVertex(v0))
		assert.NotNil(t, g2.ValueVertex(v1))
		assert.Nil(t, g2.ValueVertex(v2))
	}
}

// deterministically hashes a Graph
func graphStr(g *Graph) string {
	var vStr func(vertex) string
	var oeStr func(OpenEdge) string
	vStr = func(v vertex) string {
		if v.VertexType == ValueVertex {
			return fmt.Sprintf("v:%q\n", v.val.V.(string))
		}
		s := fmt.Sprintf("j:%d\n", len(v.in))
		ssOE := make([]string, len(v.in))
		for i := range v.in {
			ssOE[i] = oeStr(v.in[i])
		}
		sort.Strings(ssOE)
		return s + strings.Join(ssOE, "")
	}
	oeStr = func(oe OpenEdge) string {
		s := fmt.Sprintf("oe:%q\n", oe.val.V.(string))
		return s + vStr(oe.fromV)
	}
	sVV := make([]string, 0, len(g.vM))
	for _, v := range g.vM {
		sVV = append(sVV, vStr(v))
	}
	sort.Strings(sVV)
	return strings.Join(sVV, "")
}

func assertEqualSets(t *T, exp, got []*Graph) bool {
	if !assert.Equal(t, len(exp), len(got)) {
		return false
	}

	m := map[*Graph]string{}
	for _, g := range exp {
		m[g] = graphStr(g)
	}
	for _, g := range got {
		m[g] = graphStr(g)
	}

	sort.Slice(exp, func(i, j int) bool {
		return m[exp[i]] < m[exp[j]]
	})
	sort.Slice(got, func(i, j int) bool {
		return m[got[i]] < m[got[j]]
	})

	b := true
	for i := range exp {
		b = b || assert.True(t, Equal(exp[i], got[i]), "i:%d exp:%q got:%q", i, m[exp[i]], m[got[i]])
	}
	return b
}

func TestGraphUnion(t *T) {
	assertUnion := func(g1, g2 *Graph) *Graph {
		ga := g1.Union(g2)
		gb := g2.Union(g1)
		assert.True(t, Equal(ga, gb))
		return ga
	}

	assertDisjoin := func(g *Graph, exp ...*Graph) {
		ggDisj := g.Disjoin()
		assertEqualSets(t, exp, ggDisj)
	}

	v0 := NewValue("v0")
	v1 := NewValue("v1")
	e0 := NewValue("e0")
	{ // Union with ZeroGraph
		assert.True(t, Equal(ZeroGraph, ZeroGraph.Union(ZeroGraph)))

		g := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
		assert.True(t, Equal(g, assertUnion(g, ZeroGraph)))

		assertDisjoin(g, g)
	}

	v2 := NewValue("v2")
	v3 := NewValue("v3")
	e1 := NewValue("e1")
	{ // Two disparate graphs union'd
		g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
		g1 := ZeroGraph.AddValueIn(ValueOut(v2, e1), v3)
		g := assertUnion(g0, g1)
		assertVertexEqual(t, value(v0), g.ValueVertex(v0))
		assertVertexEqual(t, value(v1, edge(e0, value(v0))), g.ValueVertex(v1))
		assertVertexEqual(t, value(v2), g.ValueVertex(v2))
		assertVertexEqual(t, value(v3, edge(e1, value(v2))), g.ValueVertex(v3))

		assertDisjoin(g, g0, g1)
	}

	va0, vb0 := NewValue("va0"), NewValue("vb0")
	va1, vb1 := NewValue("va1"), NewValue("vb1")
	va2, vb2 := NewValue("va2"), NewValue("vb2")
	ea0, eb0 := NewValue("ea0"), NewValue("eb0")
	ea1, eb1 := NewValue("ea1"), NewValue("eb1")
	eaj, ebj := NewValue("eaj"), NewValue("ebj")
	{ // Two disparate graphs with tuples
		ga := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{
			ValueOut(va0, ea0),
			ValueOut(va1, ea1),
		}, eaj), va2)
		gb := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{
			ValueOut(vb0, eb0),
			ValueOut(vb1, eb1),
		}, ebj), vb2)
		g := assertUnion(ga, gb)
		assertVertexEqual(t, value(va0), g.ValueVertex(va0))
		assertVertexEqual(t, value(va1), g.ValueVertex(va1))
		assertVertexEqual(t,
			value(va2, tuple(eaj,
				edge(ea0, value(va0)),
				edge(ea1, value(va1)))),
			g.ValueVertex(va2),
		)
		assertVertexEqual(t, value(vb0), g.ValueVertex(vb0))
		assertVertexEqual(t, value(vb1), g.ValueVertex(vb1))
		assertVertexEqual(t,
			value(vb2, tuple(ebj,
				edge(eb0, value(vb0)),
				edge(eb1, value(vb1)))),
			g.ValueVertex(vb2),
		)

		assertDisjoin(g, ga, gb)
	}

	{ // Two partially overlapping graphs
		g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v2)
		g1 := ZeroGraph.AddValueIn(ValueOut(v1, e1), v2)
		g := assertUnion(g0, g1)
		assertVertexEqual(t, value(v0), g.ValueVertex(v0))
		assertVertexEqual(t, value(v1), g.ValueVertex(v1))
		assertVertexEqual(t,
			value(v2,
				edge(e0, value(v0)),
				edge(e1, value(v1)),
			),
			g.ValueVertex(v2),
		)

		assertDisjoin(g, g)
	}

	ej0 := NewValue("ej0")
	ej1 := NewValue("ej1")
	{ // two partially overlapping graphs with tuples
		g0 := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{
			ValueOut(v0, e0),
			ValueOut(v1, e1),
		}, ej0), v2)
		g1 := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{
			ValueOut(v0, e0),
			ValueOut(v1, e1),
		}, ej1), v2)
		g := assertUnion(g0, g1)
		assertVertexEqual(t, value(v0), g.ValueVertex(v0))
		assertVertexEqual(t, value(v1), g.ValueVertex(v1))
		assertVertexEqual(t,
			value(v2,
				tuple(ej0, edge(e0, value(v0)), edge(e1, value(v1))),
				tuple(ej1, edge(e0, value(v0)), edge(e1, value(v1))),
			),
			g.ValueVertex(v2),
		)

		assertDisjoin(g, g)
	}

	{ // Two equal graphs
		g0 := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
		g := assertUnion(g0, g0)
		assertVertexEqual(t, value(v0), g.ValueVertex(v0))
		assertVertexEqual(t,
			value(v1, edge(e0, value(v0))),
			g.ValueVertex(v1),
		)
	}

	{ // Two equal graphs with tuples
		g0 := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{
			ValueOut(v0, e0),
			ValueOut(v1, e1),
		}, ej0), v2)
		g := assertUnion(g0, g0)
		assertVertexEqual(t, value(v0), g.ValueVertex(v0))
		assertVertexEqual(t, value(v1), g.ValueVertex(v1))
		assertVertexEqual(t,
			value(v2,
				tuple(ej0, edge(e0, value(v0)), edge(e1, value(v1))),
			),
			g.ValueVertex(v2),
		)
	}
}

func TestGraphEqual(t *T) {
	assertEqual := func(g1, g2 *Graph) {
		assert.True(t, Equal(g1, g2))
		assert.True(t, Equal(g2, g1))
	}

	assertNotEqual := func(g1, g2 *Graph) {
		assert.False(t, Equal(g1, g2))
		assert.False(t, Equal(g2, g1))
	}

	assertEqual(ZeroGraph, ZeroGraph) // duh

	v0 := NewValue("v0")
	v1 := NewValue("v1")
	v2 := NewValue("v2")
	e0 := NewValue("e0")
	e1 := NewValue("e1")
	e1a, e1b := NewValue("e1a"), NewValue("e1b")
	{
		// graph is equal to itself, not to null
		e0 := ValueOut(v0, e0)
		g0 := ZeroGraph.AddValueIn(e0, v1)
		assertNotEqual(g0, ZeroGraph)
		assertEqual(g0, g0)

		// adding the an existing edge again shouldn't do anything
		assertEqual(g0, g0.AddValueIn(e0, v1))

		// g1a and g1b have the same vertices, but the edges are different
		g1a := g0.AddValueIn(ValueOut(v0, e1a), v2)
		g1b := g0.AddValueIn(ValueOut(v0, e1b), v2)
		assertNotEqual(g1a, g1b)
	}

	{ // equal construction should yield equality, even if out of order
		ga := ZeroGraph.AddValueIn(ValueOut(v0, e0), v1)
		ga = ga.AddValueIn(ValueOut(v1, e1), v2)
		gb := ZeroGraph.AddValueIn(ValueOut(v1, e1), v2)
		gb = gb.AddValueIn(ValueOut(v0, e0), v1)
		assertEqual(ga, gb)
	}

	ej := NewValue("ej")
	{ // tuple basic test
		e0 := ValueOut(v0, e0)
		e1 := ValueOut(v1, e1)
		ga := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{e0, e1}, ej), v2)
		gb := ZeroGraph.AddValueIn(TupleOut([]OpenEdge{e1, e0}, ej), v2)
		assertEqual(ga, ga)
		assertNotEqual(ga, gb)
	}
}