package graph

import (
	"errors"
	"fmt"
	"strconv"
	"testing"

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

type S string

func (s S) Equal(s2 Value) bool { return s == s2.(S) }

func (s S) String() string { return string(s) }

type I int

func (i I) Equal(i2 Value) bool { return i == i2.(I) }

func (i I) String() string { return strconv.Itoa(int(i)) }

func TestEqual(t *testing.T) {

	var (
		zeroValue S
		zeroGraph = new(Graph[S, S])
	)

	tests := []struct {
		a, b *Graph[S, S]
		exp  bool
	}{
		{
			a:   zeroGraph,
			b:   zeroGraph,
			exp: true,
		},
		{
			a:   zeroGraph,
			b:   zeroGraph.AddValueIn("out", ValueOut[S, S]("incr", "in")),
			exp: false,
		},
		{
			a:   zeroGraph.AddValueIn("out", ValueOut[S, S]("incr", "in")),
			b:   zeroGraph.AddValueIn("out", ValueOut[S, S]("incr", "in")),
			exp: true,
		},
		{
			a: zeroGraph.AddValueIn("out", ValueOut[S, S]("incr", "in")),
			b: zeroGraph.AddValueIn("out", TupleOut[S, S](
				"add",
				ValueOut[S, S]("ident", "in"),
				ValueOut[S, S]("ident", "1"),
			)),
			exp: false,
		},
		{
			// tuples are different order
			a: zeroGraph.AddValueIn("out", TupleOut[S, S](
				"add",
				ValueOut[S, S]("ident", "1"),
				ValueOut[S, S]("ident", "in"),
			)),
			b: zeroGraph.AddValueIn("out", TupleOut[S, S](
				"add",
				ValueOut[S, S]("ident", "in"),
				ValueOut[S, S]("ident", "1"),
			)),
			exp: false,
		},
		{
			// tuple with no edge value and just a single input edge should be
			// equivalent to just that edge.
			a: zeroGraph.AddValueIn("out", TupleOut[S, S](
				zeroValue,
				ValueOut[S, S]("ident", "1"),
			)),
			b:   zeroGraph.AddValueIn("out", ValueOut[S, S]("ident", "1")),
			exp: true,
		},
		{
			// tuple with an edge value and just a single input edge that has no
			// edgeVal should be equivalent to just that edge with the tuple's
			// edge value.
			a: zeroGraph.AddValueIn("out", TupleOut[S, S](
				"ident",
				ValueOut[S, S](zeroValue, "1"),
			)),
			b:   zeroGraph.AddValueIn("out", ValueOut[S, S]("ident", "1")),
			exp: true,
		},
		{
			a: zeroGraph.
				AddValueIn("out", ValueOut[S, S]("incr", "in")).
				AddValueIn("out2", ValueOut[S, S]("incr2", "in2")),
			b: zeroGraph.
				AddValueIn("out", ValueOut[S, S]("incr", "in")),
			exp: false,
		},
		{
			a: zeroGraph.
				AddValueIn("out", ValueOut[S, S]("incr", "in")).
				AddValueIn("out2", ValueOut[S, S]("incr2", "in2")),
			b: zeroGraph.
				AddValueIn("out", ValueOut[S, S]("incr", "in")).
				AddValueIn("out2", ValueOut[S, S]("incr2", "in2")),
			exp: true,
		},
		{
			// order of value ins shouldn't matter
			a: zeroGraph.
				AddValueIn("out", ValueOut[S, S]("incr", "in")).
				AddValueIn("out2", ValueOut[S, S]("incr2", "in2")),
			b: zeroGraph.
				AddValueIn("out2", ValueOut[S, S]("incr2", "in2")).
				AddValueIn("out", ValueOut[S, S]("incr", "in")),
			exp: true,
		},
	}

	for i, test := range tests {
		t.Run(strconv.Itoa(i), func(t *testing.T) {
			assert.Equal(t, test.exp, test.a.Equal(test.b))
		})
	}
}

type mapReduceTestEdge struct {
	name string
	fn   func([]int) int
	done bool
}

func (e *mapReduceTestEdge) Equal(e2i Value) bool {

	e2, _ := e2i.(*mapReduceTestEdge)

	if e == nil || e2 == nil {
		return e == e2
	}

	return e.name == e2.name
}

func (e *mapReduceTestEdge) String() string {
	return e.name
}

func (e *mapReduceTestEdge) do(ii []int) int {

	if e.done {
		panic(fmt.Sprintf("%q already done", e.name))
	}

	e.done = true

	return e.fn(ii)
}

func TestMapReduce(t *testing.T) {

	type (
		Va   = I
		Vb   = int
		Ea   = *mapReduceTestEdge
		edge = OpenEdge[Ea, Va]
	)

	var (
		zeroVb Vb
	)

	vOut := func(edge Ea, val Va) *edge {
		return ValueOut[Ea, Va](edge, val)
	}

	tOut := func(edge Ea, ins ...*edge) *edge {
		return TupleOut[Ea, Va](edge, ins...)
	}

	add := func() *mapReduceTestEdge {
		return &mapReduceTestEdge{
			name: "add",
			fn: func(ii []int) int {
				var n int
				for _, i := range ii {
					n += i
				}
				return n
			},
		}
	}

	mul := func() *mapReduceTestEdge {
		return &mapReduceTestEdge{
			name: "mul",
			fn: func(ii []int) int {
				n := 1
				for _, i := range ii {
					n *= i
				}
				return n
			},
		}
	}

	mapVal := func(valA Va) (Vb, error) {
		return Vb(valA * 10), nil
	}

	reduceEdge := func(edgeA Ea, valBs []Vb) (Vb, error) {

		if edgeA == nil {

			if len(valBs) == 1 {
				return valBs[0], nil
			}

			return zeroVb, errors.New("tuple edge must have edge value")
		}

		return edgeA.do(valBs), nil
	}

	tests := []struct {
		in  *edge
		exp int
	}{
		{
			in:  vOut(nil, 1),
			exp: 10,
		},
		{
			in:  vOut(add(), 1),
			exp: 10,
		},
		{
			in: tOut(
				add(),
				vOut(nil, 1),
				vOut(add(), 2),
				vOut(mul(), 3),
			),
			exp: 60,
		},
		{
			// duplicate edges and values getting used twice, each should only
			// get eval'd once
			in: tOut(
				add(),
				tOut(add(), vOut(nil, 1), vOut(nil, 2)),
				tOut(add(), vOut(nil, 1), vOut(nil, 2)),
				tOut(add(), vOut(nil, 3), vOut(nil, 3)),
			),
			exp: 120,
		},
	}

	for i, test := range tests {
		t.Run(strconv.Itoa(i), func(t *testing.T) {
			got, err := MapReduce(test.in, mapVal, reduceEdge)
			assert.NoError(t, err)
			assert.Equal(t, test.exp, got)
		})
	}
}