package client

import (
	"crypto/sha1"
	"testing"

	"storrent/bt"
)

func TestPut(t *testing.T) {
	tests := []struct {
		in   string
		hash [20]byte
		want bool
	}{
		{
			in:   "hello",
			hash: sha1.Sum([]byte("hello")),
			want: true,
		},
		{
			in:   "wrong",
			hash: sha1.Sum([]byte("hello")),
			want: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.in, func(t *testing.T) {
			p := &piece{
				hash:    tt.hash,
				size:    int64(len(tt.in)),
				data:    make([]byte, len(tt.in)),
				have:    make([]bool, 1),
				reqs:    make([]bool, 1),
				reqPeer: make([]*bt.Peer, 1),
			}
			if got := p.put(0, []byte(tt.in)); got != tt.want {
				t.Errorf("got %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPutMultiple(t *testing.T) {
	data := make([]byte, bt.BlockSize+5)
	for i := range data {
		data[i] = byte(i)
	}
	p := &piece{
		hash:    sha1.Sum(data),
		size:    int64(len(data)),
		data:    make([]byte, len(data)),
		have:    make([]bool, 2),
		reqs:    make([]bool, 2),
		reqPeer: make([]*bt.Peer, 2),
	}

	tests := []struct {
		name  string
		begin int
		data  []byte
		want  bool
	}{
		{
			name:  "first block",
			begin: 0,
			data:  data[:bt.BlockSize],
			want:  false,
		},
		{
			name:  "second block",
			begin: bt.BlockSize,
			data:  data[bt.BlockSize:],
			want:  true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := p.put(tt.begin, tt.data); got != tt.want {
				t.Errorf("got %v, want %v", got, tt.want)
			}
		})
	}
}

func TestNextRequest(t *testing.T) {
	tests := []struct {
		name       string
		pieceSize  int64
		have       []bool
		wantLength uint32
	}{
		{
			name:       "last block partial",
			pieceSize:  bt.BlockSize + 100,
			have:       []bool{true, false},
			wantLength: 100,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ps := &pieceScheduler{
				pieces: []piece{{
					size:    tt.pieceSize,
					have:    tt.have,
					reqs:    make([]bool, len(tt.have)),
					reqPeer: make([]*bt.Peer, len(tt.have)),
				}},
				incomplete: []int{0},
			}
			c := &bt.Peer{Have: []bool{true}}
			msg := ps.nextRequest(c)
			if msg == nil {
				t.Fatal("expected request")
			}
			if msg.Length != tt.wantLength {
				t.Errorf("got %d, want %d", msg.Length, tt.wantLength)
			}
		})
	}
}