package model_test

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"go.yandata.net/iod/iod/trustlog-sdk/api/model"
)

func TestNewSM2Signer(t *testing.T) {
	t.Parallel()

	privateKey := []byte("test-private-key")
	publicKey := []byte("test-public-key")

	signer := model.NewSM2Signer(privateKey, publicKey)
	assert.NotNil(t, signer)
}

func TestNewNopSigner(t *testing.T) {
	t.Parallel()

	signer := model.NewNopSigner()
	assert.NotNil(t, signer)
}

func TestNopSigner_Sign(t *testing.T) {
	t.Parallel()

	signer := model.NewNopSigner()
	data := []byte("test data")

	result, err := signer.Sign(data)
	require.NoError(t, err)
	assert.Equal(t, data, result)
	assert.NotSame(t, &data[0], &result[0]) // Should be a copy
}

func TestNopSigner_Sign_Empty(t *testing.T) {
	t.Parallel()

	signer := model.NewNopSigner()
	data := []byte{}

	result, err := signer.Sign(data)
	require.NoError(t, err)
	assert.Equal(t, data, result)
}

func TestNopSigner_Verify_Success(t *testing.T) {
	t.Parallel()

	signer := model.NewNopSigner()
	data := []byte("test data")
	signature := []byte("test data") // Same as data

	valid, err := signer.Verify(data, signature)
	require.NoError(t, err)
	assert.True(t, valid)
}

func TestNopSigner_Verify_Failure(t *testing.T) {
	t.Parallel()

	signer := model.NewNopSigner()
	data := []byte("test data")
	signature := []byte("different data")

	valid, err := signer.Verify(data, signature)
	require.NoError(t, err)
	assert.False(t, valid)
}

func TestNopSigner_RoundTrip(t *testing.T) {
	t.Parallel()

	signer := model.NewNopSigner()
	data := []byte("test data")

	signature, err := signer.Sign(data)
	require.NoError(t, err)

	valid, err := signer.Verify(data, signature)
	require.NoError(t, err)
	assert.True(t, valid)
}

func TestNopSigner_Verify_DifferentLengths(t *testing.T) {
	t.Parallel()

	signer := model.NewNopSigner()

	tests := []struct {
		name      string
		data      []byte
		signature []byte
		expected  bool
	}{
		{
			name:      "same data",
			data:      []byte("test"),
			signature: []byte("test"),
			expected:  true,
		},
		{
			name:      "different data",
			data:      []byte("test"),
			signature: []byte("test2"),
			expected:  false,
		},
		{
			name:      "different lengths",
			data:      []byte("test"),
			signature: []byte("test1"),
			expected:  false,
		},
		{
			name:      "empty",
			data:      []byte{},
			signature: []byte{},
			expected:  true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			valid, err := signer.Verify(tt.data, tt.signature)
			require.NoError(t, err)
			assert.Equal(t, tt.expected, valid)
		})
	}
}