// Copyright 2010 The Go 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 netchan

import (
	"net"
	"strings"
	"testing"
	"time"
)

const count = 10     // number of items in most tests
const closeCount = 5 // number of items when sender closes early

const base = 23

func exportSend(exp *Exporter, n int, t *testing.T, done chan bool) {
	ch := make(chan int)
	err := exp.Export("exportedSend", ch, Send)
	if err != nil {
		t.Fatal("exportSend:", err)
	}
	go func() {
		for i := 0; i < n; i++ {
			ch <- base + i
		}
		close(ch)
		if done != nil {
			done <- true
		}
	}()
}

func exportReceive(exp *Exporter, t *testing.T, expDone chan bool) {
	ch := make(chan int)
	err := exp.Export("exportedRecv", ch, Recv)
	expDone <- true
	if err != nil {
		t.Fatal("exportReceive:", err)
	}
	for i := 0; i < count; i++ {
		v, ok := <-ch
		if !ok {
			if i != closeCount {
				t.Errorf("exportReceive expected close at %d; got one at %d", closeCount, i)
			}
			break
		}
		if v != base+i {
			t.Errorf("export Receive: bad value: expected %d+%d=%d; got %d", base, i, base+i, v)
		}
	}
}

func importSend(imp *Importer, n int, t *testing.T, done chan bool) {
	ch := make(chan int)
	err := imp.ImportNValues("exportedRecv", ch, Send, 3, -1)
	if err != nil {
		t.Fatal("importSend:", err)
	}
	go func() {
		for i := 0; i < n; i++ {
			ch <- base + i
		}
		close(ch)
		if done != nil {
			done <- true
		}
	}()
}

func importReceive(imp *Importer, t *testing.T, done chan bool) {
	ch := make(chan int)
	err := imp.ImportNValues("exportedSend", ch, Recv, 3, count)
	if err != nil {
		t.Fatal("importReceive:", err)
	}
	for i := 0; i < count; i++ {
		v, ok := <-ch
		if !ok {
			if i != closeCount {
				t.Errorf("importReceive expected close at %d; got one at %d", closeCount, i)
			}
			break
		}
		if v != base+i {
			t.Errorf("importReceive: bad value: expected %d+%d=%d; got %+d", base, i, base+i, v)
		}
	}
	if done != nil {
		done <- true
	}
}

func TestExportSendImportReceive(t *testing.T) {
	exp, imp := pair(t)
	exportSend(exp, count, t, nil)
	importReceive(imp, t, nil)
}

func TestExportReceiveImportSend(t *testing.T) {
	exp, imp := pair(t)
	expDone := make(chan bool)
	done := make(chan bool)
	go func() {
		exportReceive(exp, t, expDone)
		done <- true
	}()
	<-expDone
	importSend(imp, count, t, nil)
	<-done
}

func TestClosingExportSendImportReceive(t *testing.T) {
	exp, imp := pair(t)
	exportSend(exp, closeCount, t, nil)
	importReceive(imp, t, nil)
}

func TestClosingImportSendExportReceive(t *testing.T) {
	exp, imp := pair(t)
	expDone := make(chan bool)
	done := make(chan bool)
	go func() {
		exportReceive(exp, t, expDone)
		done <- true
	}()
	<-expDone
	importSend(imp, closeCount, t, nil)
	<-done
}

func TestErrorForIllegalChannel(t *testing.T) {
	exp, imp := pair(t)
	// Now export a channel.
	ch := make(chan int, 1)
	err := exp.Export("aChannel", ch, Send)
	if err != nil {
		t.Fatal("export:", err)
	}
	ch <- 1234
	close(ch)
	// Now try to import a different channel.
	ch = make(chan int)
	err = imp.Import("notAChannel", ch, Recv, 1)
	if err != nil {
		t.Fatal("import:", err)
	}
	// Expect an error now.  Start a timeout.
	timeout := make(chan bool, 1) // buffered so closure will not hang around.
	go func() {
		time.Sleep(10 * time.Second) // very long, to give even really slow machines a chance.
		timeout <- true
	}()
	select {
	case err = <-imp.Errors():
		if strings.Index(err.Error(), "no such channel") < 0 {
			t.Error("wrong error for nonexistent channel:", err)
		}
	case <-timeout:
		t.Error("import of nonexistent channel did not receive an error")
	}
}

// Not a great test but it does at least invoke Drain.
func TestExportDrain(t *testing.T) {
	exp, imp := pair(t)
	done := make(chan bool)
	go func() {
		exportSend(exp, closeCount, t, nil)
		done <- true
	}()
	<-done
	go importReceive(imp, t, done)
	exp.Drain(0)
	<-done
}

// Not a great test but it does at least invoke Drain.
func TestImportDrain(t *testing.T) {
	exp, imp := pair(t)
	expDone := make(chan bool)
	go exportReceive(exp, t, expDone)
	<-expDone
	importSend(imp, closeCount, t, nil)
	imp.Drain(0)
}

// Not a great test but it does at least invoke Sync.
func TestExportSync(t *testing.T) {
	exp, imp := pair(t)
	done := make(chan bool)
	exportSend(exp, closeCount, t, nil)
	go importReceive(imp, t, done)
	exp.Sync(0)
	<-done
}

// Test hanging up the send side of an export.
// TODO: test hanging up the receive side of an export.
func TestExportHangup(t *testing.T) {
	exp, imp := pair(t)
	ech := make(chan int)
	err := exp.Export("exportedSend", ech, Send)
	if err != nil {
		t.Fatal("export:", err)
	}
	// Prepare to receive two values. We'll actually deliver only one.
	ich := make(chan int)
	err = imp.ImportNValues("exportedSend", ich, Recv, 1, 2)
	if err != nil {
		t.Fatal("import exportedSend:", err)
	}
	// Send one value, receive it.
	const Value = 1234
	ech <- Value
	v := <-ich
	if v != Value {
		t.Fatal("expected", Value, "got", v)
	}
	// Now hang up the channel.  Importer should see it close.
	exp.Hangup("exportedSend")
	v, ok := <-ich
	if ok {
		t.Fatal("expected channel to be closed; got value", v)
	}
}

// Test hanging up the send side of an import.
// TODO: test hanging up the receive side of an import.
func TestImportHangup(t *testing.T) {
	exp, imp := pair(t)
	ech := make(chan int)
	err := exp.Export("exportedRecv", ech, Recv)
	if err != nil {
		t.Fatal("export:", err)
	}
	// Prepare to Send two values. We'll actually deliver only one.
	ich := make(chan int)
	err = imp.ImportNValues("exportedRecv", ich, Send, 1, 2)
	if err != nil {
		t.Fatal("import exportedRecv:", err)
	}
	// Send one value, receive it.
	const Value = 1234
	ich <- Value
	v := <-ech
	if v != Value {
		t.Fatal("expected", Value, "got", v)
	}
	// Now hang up the channel.  Exporter should see it close.
	imp.Hangup("exportedRecv")
	v, ok := <-ech
	if ok {
		t.Fatal("expected channel to be closed; got value", v)
	}
}

// loop back exportedRecv to exportedSend,
// but receive a value from ctlch before starting the loop.
func exportLoopback(exp *Exporter, t *testing.T) {
	inch := make(chan int)
	if err := exp.Export("exportedRecv", inch, Recv); err != nil {
		t.Fatal("exportRecv")
	}

	outch := make(chan int)
	if err := exp.Export("exportedSend", outch, Send); err != nil {
		t.Fatal("exportSend")
	}

	ctlch := make(chan int)
	if err := exp.Export("exportedCtl", ctlch, Recv); err != nil {
		t.Fatal("exportRecv")
	}

	go func() {
		<-ctlch
		for i := 0; i < count; i++ {
			x := <-inch
			if x != base+i {
				t.Errorf("exportLoopback expected %d; got %d", i, x)
			}
			outch <- x
		}
	}()
}

// This test checks that channel operations can proceed
// even when other concurrent operations are blocked.
func TestIndependentSends(t *testing.T) {
	exp, imp := pair(t)

	exportLoopback(exp, t)

	importSend(imp, count, t, nil)
	done := make(chan bool)
	go importReceive(imp, t, done)

	// wait for export side to try to deliver some values.
	time.Sleep(250 * time.Millisecond)

	ctlch := make(chan int)
	if err := imp.ImportNValues("exportedCtl", ctlch, Send, 1, 1); err != nil {
		t.Fatal("importSend:", err)
	}
	ctlch <- 0

	<-done
}

// This test cross-connects a pair of exporter/importer pairs.
type value struct {
	I      int
	Source string
}

func TestCrossConnect(t *testing.T) {
	e1, i1 := pair(t)
	e2, i2 := pair(t)

	crossExport(e1, e2, t)
	crossImport(i1, i2, t)
}

// Export side of cross-traffic.
func crossExport(e1, e2 *Exporter, t *testing.T) {
	s := make(chan value)
	err := e1.Export("exportedSend", s, Send)
	if err != nil {
		t.Fatal("exportSend:", err)
	}

	r := make(chan value)
	err = e2.Export("exportedReceive", r, Recv)
	if err != nil {
		t.Fatal("exportReceive:", err)
	}

	go crossLoop("export", s, r, t)
}

// Import side of cross-traffic.
func crossImport(i1, i2 *Importer, t *testing.T) {
	s := make(chan value)
	err := i2.Import("exportedReceive", s, Send, 2)
	if err != nil {
		t.Fatal("import of exportedReceive:", err)
	}

	r := make(chan value)
	err = i1.Import("exportedSend", r, Recv, 2)
	if err != nil {
		t.Fatal("import of exported Send:", err)
	}

	crossLoop("import", s, r, t)
}

// Cross-traffic: send and receive 'count' numbers.
func crossLoop(name string, s, r chan value, t *testing.T) {
	for si, ri := 0, 0; si < count && ri < count; {
		select {
		case s <- value{si, name}:
			si++
		case v := <-r:
			if v.I != ri {
				t.Errorf("loop: bad value: expected %d, hello; got %+v", ri, v)
			}
			ri++
		}
	}
}

const flowCount = 100

// test flow control from exporter to importer.
func TestExportFlowControl(t *testing.T) {
	exp, imp := pair(t)

	sendDone := make(chan bool, 1)
	exportSend(exp, flowCount, t, sendDone)

	ch := make(chan int)
	err := imp.ImportNValues("exportedSend", ch, Recv, 20, -1)
	if err != nil {
		t.Fatal("importReceive:", err)
	}

	testFlow(sendDone, ch, flowCount, t)
}

// test flow control from importer to exporter.
func TestImportFlowControl(t *testing.T) {
	exp, imp := pair(t)

	ch := make(chan int)
	err := exp.Export("exportedRecv", ch, Recv)
	if err != nil {
		t.Fatal("importReceive:", err)
	}

	sendDone := make(chan bool, 1)
	importSend(imp, flowCount, t, sendDone)
	testFlow(sendDone, ch, flowCount, t)
}

func testFlow(sendDone chan bool, ch <-chan int, N int, t *testing.T) {
	go func() {
		time.Sleep(500 * time.Millisecond)
		sendDone <- false
	}()

	if <-sendDone {
		t.Fatal("send did not block")
	}
	n := 0
	for i := range ch {
		t.Log("after blocking, got value ", i)
		n++
	}
	if n != N {
		t.Fatalf("expected %d values; got %d", N, n)
	}
}

func pair(t *testing.T) (*Exporter, *Importer) {
	c0, c1 := net.Pipe()
	exp := NewExporter()
	go exp.ServeConn(c0)
	imp := NewImporter(c1)
	return exp, imp
}