package tracker

import (
	"bytes"
	"crypto/rand"
	"encoding/binary"
	"io"
	"io/ioutil"
	"log"
	"net"
	"net/url"
	"sync"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/anacrolix/torrent/util"
)

// Ensure net.IPs are stored big-endian, to match the way they're read from
// the wire.
func TestNetIPv4Bytes(t *testing.T) {
	ip := net.IP([]byte{127, 0, 0, 1})
	if ip.String() != "127.0.0.1" {
		t.FailNow()
	}
	if string(ip) != "\x7f\x00\x00\x01" {
		t.Fatal([]byte(ip))
	}
}

func TestMarshalAnnounceResponse(t *testing.T) {
	w := bytes.Buffer{}
	peers := util.CompactPeers{{[4]byte{127, 0, 0, 1}, 2}, {[4]byte{255, 0, 0, 3}, 4}}
	err := peers.WriteBinary(&w)
	if err != nil {
		t.Fatalf("error writing udp announce response addrs: %s", err)
	}
	if w.String() != "\x7f\x00\x00\x01\x00\x02\xff\x00\x00\x03\x00\x04" {
		t.FailNow()
	}
	if binary.Size(AnnounceResponseHeader{}) != 12 {
		t.FailNow()
	}
}

// Failure to write an entire packet to UDP is expected to given an error.
func TestLongWriteUDP(t *testing.T) {
	l, err := net.ListenUDP("udp", nil)
	defer l.Close()
	if err != nil {
		t.Fatal(err)
	}
	c, err := net.DialUDP("udp", nil, l.LocalAddr().(*net.UDPAddr))
	if err != nil {
		t.Fatal(err)
	}
	defer c.Close()
	for msgLen := 1; ; msgLen *= 2 {
		n, err := c.Write(make([]byte, msgLen))
		if err != nil {
			require.Contains(t, err.Error(), "message too long")
			return
		}
		if n < msgLen {
			t.FailNow()
		}
	}
}

func TestShortBinaryRead(t *testing.T) {
	var data ResponseHeader
	err := binary.Read(bytes.NewBufferString("\x00\x00\x00\x01"), binary.BigEndian, &data)
	if err != io.ErrUnexpectedEOF {
		t.FailNow()
	}
}

func TestConvertInt16ToInt(t *testing.T) {
	i := 50000
	if int(uint16(int16(i))) != 50000 {
		t.FailNow()
	}
}

func TestUDPTracker(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	tr, err := New("udp://tracker.openbittorrent.com:80/announce")
	if err != nil {
		t.Skip(err)
	}
	if err := tr.Connect(); err != nil {
		t.Skip(err)
	}
	req := AnnounceRequest{
		NumWant: -1,
		Event:   Started,
	}
	rand.Read(req.PeerId[:])
	copy(req.InfoHash[:], []uint8{0xa3, 0x56, 0x41, 0x43, 0x74, 0x23, 0xe6, 0x26, 0xd9, 0x38, 0x25, 0x4a, 0x6b, 0x80, 0x49, 0x10, 0xa6, 0x67, 0xa, 0xc1})
	_, err = tr.Announce(&req)
	if err != nil {
		t.Skip(err)
	}
}

// TODO: Create a fake UDP tracker to make these requests to.
func TestAnnounceRandomInfoHash(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	req := AnnounceRequest{
		Event: Stopped,
	}
	rand.Read(req.PeerId[:])
	rand.Read(req.InfoHash[:])
	wg := sync.WaitGroup{}
	for _, url := range []string{
		"udp://tracker.openbittorrent.com:80/announce",
		"udp://tracker.publicbt.com:80",
		"udp://tracker.istole.it:6969",
		"udp://tracker.ccc.de:80",
		"udp://tracker.open.demonii.com:1337",
	} {
		go func(url string) {
			defer wg.Done()
			tr, err := New(url)
			if err != nil {
				t.Fatal(err)
			}
			if err := tr.Connect(); err != nil {
				t.Log(err)
				return
			}
			resp, err := tr.Announce(&req)
			if err != nil {
				t.Logf("error announcing to %s: %s", url, err)
				return
			}
			if resp.Leechers != 0 || resp.Seeders != 0 || len(resp.Peers) != 0 {
				t.Fatal(resp)
			}
		}(url)
		wg.Add(1)
	}
	wg.Wait()
}

// Check that URLPath option is done correctly.
func TestURLPathOption(t *testing.T) {
	conn, err := net.ListenUDP("udp", nil)
	if err != nil {
		panic(err)
	}
	defer conn.Close()
	cl := newClient(&url.URL{
		Host: conn.LocalAddr().String(),
		Path: "/announce",
	})
	go func() {
		err = cl.Connect()
		if err != nil {
			t.Fatal(err)
		}
		log.Print("connected")
		_, err = cl.Announce(&AnnounceRequest{})
		if err != nil {
			t.Fatal(err)
		}
	}()
	var b [512]byte
	_, addr, _ := conn.ReadFrom(b[:])
	r := bytes.NewReader(b[:])
	var h RequestHeader
	read(r, &h)
	w := &bytes.Buffer{}
	write(w, ResponseHeader{
		TransactionId: h.TransactionId,
	})
	write(w, ConnectionResponse{42})
	conn.WriteTo(w.Bytes(), addr)
	n, _, _ := conn.ReadFrom(b[:])
	r = bytes.NewReader(b[:n])
	read(r, &h)
	read(r, &AnnounceRequest{})
	all, _ := ioutil.ReadAll(r)
	if string(all) != "\x02\x09/announce" {
		t.FailNow()
	}
	w = &bytes.Buffer{}
	write(w, ResponseHeader{
		TransactionId: h.TransactionId,
	})
	write(w, AnnounceResponseHeader{})
	conn.WriteTo(w.Bytes(), addr)
}