package cose

import (
	"crypto"
	"crypto/sha256"
	"reflect"
	"testing"
)

// resetExtendedAlgorithm cleans up extended algorithms
func resetExtendedAlgorithm() {
	extAlgorithms = nil
}

func TestAlgorithm_String(t *testing.T) {
	defer resetExtendedAlgorithm()

	// register extended algorithms
	algFoo := Algorithm(-102)
	if err := RegisterAlgorithm(algFoo, "foo", 0, nil); err != nil {
		t.Fatalf("RegisterAlgorithm() = %v", err)
	}
	algBar := Algorithm(-98)
	if err := RegisterAlgorithm(algBar, "bar", 0, nil); err != nil {
		t.Fatalf("RegisterAlgorithm() = %v", err)
	}

	// run tests
	tests := []struct {
		name string
		alg  Algorithm
		want string
	}{
		{
			name: "PS256",
			alg:  AlgorithmPS256,
			want: "PS256",
		},
		{
			name: "PS384",
			alg:  AlgorithmPS384,
			want: "PS384",
		},
		{
			name: "PS512",
			alg:  AlgorithmPS512,
			want: "PS512",
		},
		{
			name: "ES256",
			alg:  AlgorithmES256,
			want: "ES256",
		},
		{
			name: "ES384",
			alg:  AlgorithmES384,
			want: "ES384",
		},
		{
			name: "ES512",
			alg:  AlgorithmES512,
			want: "ES512",
		},
		{
			name: "Ed25519",
			alg:  AlgorithmEd25519,
			want: "EdDSA",
		},
		{
			name: "extended algorithm: foo",
			alg:  algFoo,
			want: "foo",
		},
		{
			name: "extended algorithm: bar",
			alg:  algBar,
			want: "bar",
		},
		{
			name: "unknown algorithm",
			alg:  0,
			want: "unknown algorithm value 0",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.alg.String(); got != tt.want {
				t.Errorf("Algorithm.String() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestAlgorithm_computeHash(t *testing.T) {
	defer resetExtendedAlgorithm()

	// register extended algorithms
	algFoo := Algorithm(-102)
	if err := RegisterAlgorithm(algFoo, "foo", crypto.SHA256, nil); err != nil {
		t.Fatalf("RegisterAlgorithm() = %v", err)
	}
	algBar := Algorithm(-98)
	if err := RegisterAlgorithm(algBar, "bar", 0, sha256.New); err != nil {
		t.Fatalf("RegisterAlgorithm() = %v", err)
	}
	algPlain := Algorithm(-112)
	if err := RegisterAlgorithm(algPlain, "plain", 0, nil); err != nil {
		t.Fatalf("RegisterAlgorithm() = %v", err)
	}
	algUnavailableHash := Algorithm(-117)
	if err := RegisterAlgorithm(algUnavailableHash, "unknown hash", 42, nil); err != nil {
		t.Fatalf("RegisterAlgorithm() = %v", err)
	}

	// run tests
	data := []byte("hello world")
	tests := []struct {
		name    string
		alg     Algorithm
		want    []byte
		wantErr error
	}{
		{
			name: "PS256",
			alg:  AlgorithmPS256,
			want: []byte{
				0xb9, 0x4d, 0x27, 0xb9, 0x93, 0x4d, 0x3e, 0x08, 0xa5, 0x2e, 0x52, 0xd7, 0xda, 0x7d, 0xab, 0xfa,
				0xc4, 0x84, 0xef, 0xe3, 0x7a, 0x53, 0x80, 0xee, 0x90, 0x88, 0xf7, 0xac, 0xe2, 0xef, 0xcd, 0xe9,
			},
		},
		{
			name: "PS384",
			alg:  AlgorithmPS384,
			want: []byte{
				0xfd, 0xbd, 0x8e, 0x75, 0xa6, 0x7f, 0x29, 0xf7, 0x01, 0xa4, 0xe0, 0x40, 0x38, 0x5e, 0x2e, 0x23,
				0x98, 0x63, 0x03, 0xea, 0x10, 0x23, 0x92, 0x11, 0xaf, 0x90, 0x7f, 0xcb, 0xb8, 0x35, 0x78, 0xb3,
				0xe4, 0x17, 0xcb, 0x71, 0xce, 0x64, 0x6e, 0xfd, 0x08, 0x19, 0xdd, 0x8c, 0x08, 0x8d, 0xe1, 0xbd,
			},
		},
		{
			name: "PS512",
			alg:  AlgorithmPS512,
			want: []byte{
				0x30, 0x9e, 0xcc, 0x48, 0x9c, 0x12, 0xd6, 0xeb, 0x4c, 0xc4, 0x0f, 0x50, 0xc9, 0x02, 0xf2, 0xb4,
				0xd0, 0xed, 0x77, 0xee, 0x51, 0x1a, 0x7c, 0x7a, 0x9b, 0xcd, 0x3c, 0xa8, 0x6d, 0x4c, 0xd8, 0x6f,
				0x98, 0x9d, 0xd3, 0x5b, 0xc5, 0xff, 0x49, 0x96, 0x70, 0xda, 0x34, 0x25, 0x5b, 0x45, 0xb0, 0xcf,
				0xd8, 0x30, 0xe8, 0x1f, 0x60, 0x5d, 0xcf, 0x7d, 0xc5, 0x54, 0x2e, 0x93, 0xae, 0x9c, 0xd7, 0x6f,
			},
		},
		{
			name: "ES256",
			alg:  AlgorithmES256,
			want: []byte{
				0xb9, 0x4d, 0x27, 0xb9, 0x93, 0x4d, 0x3e, 0x08, 0xa5, 0x2e, 0x52, 0xd7, 0xda, 0x7d, 0xab, 0xfa,
				0xc4, 0x84, 0xef, 0xe3, 0x7a, 0x53, 0x80, 0xee, 0x90, 0x88, 0xf7, 0xac, 0xe2, 0xef, 0xcd, 0xe9,
			},
		},
		{
			name: "ES384",
			alg:  AlgorithmES384,
			want: []byte{
				0xfd, 0xbd, 0x8e, 0x75, 0xa6, 0x7f, 0x29, 0xf7, 0x01, 0xa4, 0xe0, 0x40, 0x38, 0x5e, 0x2e, 0x23,
				0x98, 0x63, 0x03, 0xea, 0x10, 0x23, 0x92, 0x11, 0xaf, 0x90, 0x7f, 0xcb, 0xb8, 0x35, 0x78, 0xb3,
				0xe4, 0x17, 0xcb, 0x71, 0xce, 0x64, 0x6e, 0xfd, 0x08, 0x19, 0xdd, 0x8c, 0x08, 0x8d, 0xe1, 0xbd,
			},
		},
		{
			name: "ES512",
			alg:  AlgorithmES512,
			want: []byte{
				0x30, 0x9e, 0xcc, 0x48, 0x9c, 0x12, 0xd6, 0xeb, 0x4c, 0xc4, 0x0f, 0x50, 0xc9, 0x02, 0xf2, 0xb4,
				0xd0, 0xed, 0x77, 0xee, 0x51, 0x1a, 0x7c, 0x7a, 0x9b, 0xcd, 0x3c, 0xa8, 0x6d, 0x4c, 0xd8, 0x6f,
				0x98, 0x9d, 0xd3, 0x5b, 0xc5, 0xff, 0x49, 0x96, 0x70, 0xda, 0x34, 0x25, 0x5b, 0x45, 0xb0, 0xcf,
				0xd8, 0x30, 0xe8, 0x1f, 0x60, 0x5d, 0xcf, 0x7d, 0xc5, 0x54, 0x2e, 0x93, 0xae, 0x9c, 0xd7, 0x6f,
			},
		},
		{
			name: "Ed25519",
			alg:  AlgorithmEd25519,
			want: data,
		},
		{
			name: "extended algorithm with crypto.Hash",
			alg:  algFoo,
			want: []byte{
				0xb9, 0x4d, 0x27, 0xb9, 0x93, 0x4d, 0x3e, 0x08, 0xa5, 0x2e, 0x52, 0xd7, 0xda, 0x7d, 0xab, 0xfa,
				0xc4, 0x84, 0xef, 0xe3, 0x7a, 0x53, 0x80, 0xee, 0x90, 0x88, 0xf7, 0xac, 0xe2, 0xef, 0xcd, 0xe9,
			},
		},
		{
			name: "extended algorithm with hashFunc",
			alg:  algBar,
			want: []byte{
				0xb9, 0x4d, 0x27, 0xb9, 0x93, 0x4d, 0x3e, 0x08, 0xa5, 0x2e, 0x52, 0xd7, 0xda, 0x7d, 0xab, 0xfa,
				0xc4, 0x84, 0xef, 0xe3, 0x7a, 0x53, 0x80, 0xee, 0x90, 0x88, 0xf7, 0xac, 0xe2, 0xef, 0xcd, 0xe9,
			},
		},
		{
			name: "extended algorithm without hash",
			alg:  algPlain,
			want: data,
		},
		{
			name:    "unknown algorithm",
			alg:     0,
			wantErr: ErrUnknownAlgorithm,
		},
		{
			name:    "unknown hash",
			alg:     algUnavailableHash,
			wantErr: ErrUnavailableHashFunc,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := tt.alg.computeHash(data)
			if err != tt.wantErr {
				t.Errorf("Algorithm.computeHash() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Algorithm.computeHash() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestRegisterAlgorithm(t *testing.T) {
	defer resetExtendedAlgorithm()

	// register existing algorithm (should fail)
	if err := RegisterAlgorithm(AlgorithmES256, "ES256", crypto.SHA256, nil); err != ErrAlgorithmRegistered {
		t.Errorf("RegisterAlgorithm() error = %v, wantErr %v", err, ErrAlgorithmRegistered)
	}

	// register external algorithm
	algFoo := Algorithm(-102)
	if err := RegisterAlgorithm(algFoo, "foo", 0, nil); err != nil {
		t.Errorf("RegisterAlgorithm() error = %v, wantErr %v", err, false)
	}

	// double register external algorithm (should fail)
	if err := RegisterAlgorithm(algFoo, "foo", 0, nil); err != ErrAlgorithmRegistered {
		t.Errorf("RegisterAlgorithm() error = %v, wantErr %v", err, ErrAlgorithmRegistered)
	}
}