package encoder

import (
	"bytes"
	"crypto/aes"
	"fmt"
	"io"
	"io/ioutil"
	"local/encryptor"
	"log"
	"strings"
	"testing"
)

func Test_Encoder2(t *testing.T) {
	cases := []struct {
		bops           []BOP
		streamLength   int
		bufferCapacity int
	}{
		{
			bops: []BOP{
				&AES{Key: []byte("key")},
			},
			streamLength:   75,
			bufferCapacity: 25,
		},
		{
			bops: []BOP{
				&Salter{},
			},
			streamLength:   75,
			bufferCapacity: 25,
		},
		{
			bops: []BOP{
				&Zipper{},
			},
			streamLength:   75,
			bufferCapacity: 25,
		},
		{
			bops: []BOP{
				&AES{Key: []byte("key")},
			},
			streamLength:   7500,
			bufferCapacity: 250,
		},
		{
			bops: []BOP{
				&Salter{},
			},
			streamLength:   7500,
			bufferCapacity: 250,
		},
		{
			bops: []BOP{
				&Zipper{},
			},
			streamLength:   7500,
			bufferCapacity: 250,
		},
		{
			bops: []BOP{
				&Zipper{},
				&Salter{},
				&AES{Key: []byte("key")},
			},
			streamLength:   75,
			bufferCapacity: 50,
		},
		{
			bops: []BOP{
				&Zipper{},
				&Salter{},
				&AES{Key: []byte("key")},
				&Zipper{},
			},
			streamLength:   0,
			bufferCapacity: 250,
		},
		{
			bops: []BOP{
				&Zipper{},
				&Salter{},
				&AES{Key: []byte("key")},
				&Zipper{},
			},
			streamLength:   76 * 1000,
			bufferCapacity: 250,
		},
		{
			bops: []BOP{
				&Zipper{},
				&Salter{},
				&AES{Key: []byte("key")},
				&Zipper{},
			},
			streamLength:   7500,
			bufferCapacity: 250,
		},
		{
			bops: []BOP{
				&Zipper{},
				&Salter{},
				&AES{Key: []byte("key")},
				&Zipper{},
			},
			streamLength:   75,
			bufferCapacity: 25,
		},
	}

	for _, c := range cases {
		log.Printf("test cap %v, input length %v, bop length %v", c.bufferCapacity, c.streamLength, len(c.bops))
		SetPipeBuffSize(c.bufferCapacity)
		enc, _ := New(nil, c.bops...)
		input := strings.Repeat("hello world", c.streamLength)[:c.streamLength]
		inputReader := strings.NewReader(input)
		encodedReader, err := enc.Encode2(inputReader)
		if err != nil {
			t.Fatalf("cannot encode2: %v", err)
		}
		encoded, err := ioutil.ReadAll(encodedReader)
		if err != nil {
			t.Fatalf("cannot read encdoed: %v", err)
		}
		encodedReader = bytes.NewReader(encoded)
		encodedBytes, err := ioutil.ReadAll(encodedReader)
		if err != nil {
			t.Fatalf("cannot read encoded all: %v", err)
		}
		log.Printf("%v -> %v -> ?", c.streamLength, len(encodedBytes))
		decodedReader, err := enc.Decode2(bytes.NewBuffer(encodedBytes))
		if err != nil {
			t.Fatalf("cannot decode2: %v", err)
		}
		out, err := ioutil.ReadAll(decodedReader)
		if err != nil {
			t.Fatalf("cannot gather decoded: %v", err)
		}
		if string(out) != input {
			t.Errorf("wrong encdoed-decoded: got %v, wanted %v", len(out), len(input))
		}
	}
}

func Test_Encoder3_Enc(t *testing.T) {
	was := pipeBuffSize
	defer func() {
		SetPipeBuffSize(int(was))
	}()
	SetPipeBuffSize(aes.BlockSize + 2)
	cases := []struct {
		bops []BOP
	}{
		{bops: []BOP{&Salter{}}},
		{bops: []BOP{&Zipper{}}},
		{bops: []BOP{&Zipper{}, &Salter{}}},
		{bops: []BOP{&Salter{}, &Zipper{}}},
		{bops: []BOP{&AES{Key: []byte("key")}}},
	}

	for _, c := range cases {
		title := "---"
		for i := range c.bops {
			title += fmt.Sprintf(" %T", c.bops[i])
		}
		enc, err := New(nil, c.bops...)
		if err != nil {
			t.Fatalf("cannot create new encoder: %v", err)
		}
		input := strings.Repeat("hello world", int(pipeBuffSize*2))[:pipeBuffSize*2]
		inputReader := bytes.NewBuffer([]byte(input))
		encodeReader, err := enc.Encode3(inputReader)
		if err != nil {
			t.Fatalf("cannot get encode reader: %v", err)
		}
		out, err := ioutil.ReadAll(encodeReader)
		if err != nil {
			t.Fatalf("cannot read from decode reader: %v", err)
		}
		t.Logf("%s : %s => %s", title, input, out)
	}
}
func Test_Encoder3_All(t *testing.T) {
	was := pipeBuffSize
	defer func() {
		SetPipeBuffSize(int(was))
	}()
	SetPipeBuffSize(aes.BlockSize + 2)
	cases := []struct {
		bops []BOP
	}{
		{bops: []BOP{&Salter{}}},
		{bops: []BOP{&Zipper{}}},
		{bops: []BOP{&AES{Key: []byte("key")}}},
		{bops: []BOP{&Zipper{}, &Salter{}}},
		{bops: []BOP{&Salter{}, &Zipper{}}},
		{bops: []BOP{&Zipper{}, &Salter{}, &AES{Key: []byte("key")}, &Zipper{}}},
	}

	for _, c := range cases {
		title := "///"
		for i := range c.bops {
			title += fmt.Sprintf(" %T", c.bops[i])
		}
		enc, err := New(nil, c.bops...)
		if err != nil {
			t.Fatalf("cannot create new encoder: %v", err)
		}
		input := strings.Repeat("hello world", int(pipeBuffSize*2))[:pipeBuffSize*2]
		inputReader := bytes.NewBuffer([]byte(input))
		encodeReader, err := enc.Encode3(inputReader)
		if err != nil {
			t.Fatalf("cannot get encode reader: %v", err)
		}
		var decodeReader io.Reader
		if false {
			encodedString, err := ioutil.ReadAll(encodeReader)
			if err != nil {
				t.Fatalf("cannot gather encoded: %v", err)
			}
			decodeReader, err = enc.Decode3(bytes.NewBuffer(encodedString))
		} else {
			decodeReader, err = enc.Decode3(encodeReader)
		}
		if err != nil {
			t.Fatalf("cannot get decode reader: %v", err)
		}
		out, err := ioutil.ReadAll(decodeReader)
		if err != nil {
			t.Fatalf("cannot read from decode reader: %v", err)
		}
		if string(out) != input {
			t.Errorf("failed test with %v bops", len(c.bops))
		}
		t.Logf("%v : %s => %s", c.bops, input, out)
	}
}

func Test_Encoder(t *testing.T) {
	input := "My secret secret"
	conf := &Config{
		SymKey:     "letme123in",
		SymKeyOnly: false,
		KeyPath:    "",
	}
	enc, err := New(conf)
	if err != nil {
		t.Fatalf("cannot create new encoder: %v", err)
	}

	packed, err := enc.Encode([]byte(input), []byte("meta"), []byte("META 22222!!!!"))
	if err != nil {
		t.Fatalf("cannot encode with new encoder: %v", err)
	}
	unpacked, err := enc.Decode(packed)
	if err != nil {
		t.Fatalf("cannot decode with new encoder: %v", err)
	}
	if string(unpacked) != input {
		t.Fatalf("unpacked != input: %v vs %v", string(unpacked), input)
	}

	packed, err = enc.Encode([]byte(input))
	if err != nil {
		t.Fatalf("cannot encode with new encoder: %v", err)
	}
	unpacked, err = enc.Decode(packed)
	if err != nil {
		t.Fatalf("cannot decode with new encoder: %v", err)
	}
	if string(unpacked) != input {
		t.Fatalf("unpacked != input: %v vs %v", string(unpacked), input)
	}

	t.Logf("prepacked: %q, packed len: %v, unpacked: %q", input, len(packed), string(unpacked))
}

var metaname = []byte("META NAME")
var metavalue = []byte("META VALUE")

func Test_Encoder_BOP_Combos(t *testing.T) {
	enc := encryptor.NewEncryptor("", "")
	sym := encryptor.NewEncryptor("", "")
	sym.SetSymmetric(sym.GetPublic())

	encAndDec(t, makeSomeEnc(), "default")
	encAndDec(t, makeSomeEnc(
		&Salter{},
		&asymCryptor{Encryptor: enc},
		&AES{Key: []byte(sym.GetPublic())},
		&Zipper{},
	), "salt_asym_sym_zip")
	encAndDec(t, makeSomeEnc(
		&Zipper{},
		&Salter{},
		&asymCryptor{Encryptor: enc},
		&AES{Key: []byte(sym.GetPublic())},
		&Zipper{},
	), "zip_salt_asym_sym_zip")
	encAndDec(t, makeSomeEnc(
		&snapper{},
		&Salter{},
		&asymCryptor{Encryptor: enc},
		&AES{Key: []byte(sym.GetPublic())},
		&snapper{},
	), "snap_salt_asym_sym_snap")
	encAndDec(t, makeSomeEnc(
		&Salter{},
		&asymCryptor{Encryptor: enc},
		&AES{Key: []byte(sym.GetPublic())},
		&Zipper{},
	), "salt_asym_sym_zip")
	encAndDec(t, makeSomeEnc(
		&Zipper{},
		&Salter{},
		&asymCryptor{Encryptor: enc},
		&AES{Key: []byte(sym.GetPublic())},
	), "zip_salt_asym_sym")
	encAndDec(t, makeSomeEnc(
		&Zipper{},
		&Salter{},
		&AES{Key: []byte(sym.GetPublic())},
		&asymCryptor{Encryptor: enc},
		&Zipper{},
	), "zip_salt_sym_asym_zip")
	encAndDec(t, makeSomeEnc(
		&Zipper{},
		&Salter{n: 50},
		&AES{Key: []byte(sym.GetPublic())},
		&asymCryptor{Encryptor: enc},
		&Zipper{},
	), "zip_salt50_sym_asym_zip")
	encAndDec(t, makeSomeEnc(
		&Zipper{},
		&Salter{n: 10},
		&AES{Key: []byte(sym.GetPublic())},
		&asymCryptor{Encryptor: enc},
		&Zipper{},
	), "zip_salt10_sym_asym_zip")
	syms := []encryptor.Encryptor{}
	for i := 0; i < 10; i++ {
		e := encryptor.NewEncryptor("", "")
		e.SetSymmetric(e.GetPublic())
		syms = append(syms, e)
	}
	encAndDec(t, makeSomeEnc(
		&Zipper{},
		&Salter{n: 10},
		&AES{Key: []byte(syms[0].GetPublic())},
		&AES{Key: []byte(syms[1].GetPublic())},
		&AES{Key: []byte(syms[2].GetPublic())},
		&AES{Key: []byte(syms[3].GetPublic())},
		&AES{Key: []byte(syms[4].GetPublic())},
		&AES{Key: []byte(syms[5].GetPublic())},
		&Zipper{},
	), "zip_salt10_sym6_zip")
	encAndDec(t, makeSomeEnc(
		&Salter{n: 10},
		&Zipper{},
		&AES{Key: []byte(sym.GetPublic())},
		&Zipper{},
	), "salt10_zip_sym_zip")
	encAndDec(t, makeSomeEnc(
		&Salter{n: 10},
		&LZ4{},
		&AES{Key: []byte(sym.GetPublic())},
		&LZ4{},
	), "salt10_lz4_sym_lz4")
	encAndDec(t, makeSomeEnc(
		&LZ4{},
		&Salter{n: 10},
		&AES{Key: []byte(sym.GetPublic())},
		&LZ4{},
	), "salt10_lz4_sym_lz4")
	encAndDec(t, makeSomeEnc(
		&LZ4{},
	), "lz4")
	encAndDec(t, makeSomeEnc(
		&Zipper{},
	), "zip")
}

func encAndDec(t *testing.T, enc *Encoder, name string) {
	input := readSomeInput()
	packed, err := enc.Encode(input, metaname, metavalue)
	if err != nil {
		t.Fatal(err)
	}
	unpacked, err := enc.Decode(packed)
	if err != nil {
		t.Fatal(err)
	}
	if string(unpacked) != string(input) {
		t.Fatalf("Unpacked != input: len %v vs %v", len(unpacked), len(input))
	}
	t.Logf("%30q: %4d -> %4d when packed (%d%%)", name, len(input), len(packed), 100.0*len(packed)/len(input))
}

func makeSomeEnc(bops ...BOP) *Encoder {
	conf := &Config{
		SymKey:     "letme123in",
		SymKeyOnly: false,
		KeyPath:    "",
	}
	e, err := New(conf, bops...)
	if err != nil {
		panic(err)
	}
	return e
}

func readSomeInput() []byte {
	b, err := ioutil.ReadFile("./encoder.go")
	if err != nil {
		panic(err)
	}
	return b
}