package bunker

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"realy.lol/context"
	"realy.lol/encryption"
	"realy.lol/event"
	"realy.lol/hex"
	"realy.lol/kind"
	"realy.lol/p256k"
	"realy.lol/tag"
	"realy.lol/tags"
	"realy.lol/timestamp"
)

func TestStaticKeySigner(t *testing.T) {
	// Create a signer for testing
	signer := new(p256k.Signer)
	err := signer.Generate()
	require.NoError(t, err)

	staticSigner := NewStaticKeySigner(signer)
	require.NotNil(t, staticSigner)

	// Test GetSession with non-existent session
	session, exists := staticSigner.GetSession("non_existent_pubkey")
	assert.False(t, exists)
	assert.Nil(t, session)

	// Test getOrCreateSession
	clientPubkey, _ := hex.Dec("3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d")
	session, err = staticSigner.getOrCreateSession(clientPubkey)
	require.NoError(t, err)
	require.NotNil(t, session)

	// Test GetSession with existing session
	session2, exists := staticSigner.GetSession(hex.Enc(clientPubkey))
	assert.True(t, exists)
	assert.Equal(t, session, session2)
}

func TestCheckParamsAndKey(t *testing.T) {
	// Test with valid request
	req := &Request{
		Method: "get_public_key",
		Params: [][]byte{},
	}

	pk, err := CheckParamsAndKey(req)
	assert.NoError(t, err)
	assert.Nil(t, pk)

	// Test with sign_event method
	req = &Request{
		Method: "sign_event",
		Params: [][]byte{[]byte(`{"pubkey":"3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"}`)},
	}

	pk, err = CheckParamsAndKey(req)
	assert.NoError(t, err)
	assert.NotNil(t, pk)

	// Test with invalid method
	req = &Request{
		Method: "invalid_method",
		Params: [][]byte{},
	}

	pk, err = CheckParamsAndKey(req)
	assert.Error(t, err)
	assert.Nil(t, pk)

	// Test with missing params
	req = &Request{
		Method: "sign_event",
		Params: [][]byte{},
	}

	pk, err = CheckParamsAndKey(req)
	assert.Error(t, err)
	assert.Nil(t, pk)

	// Test with invalid JSON
	req = &Request{
		Method: "sign_event",
		Params: [][]byte{[]byte("invalid_json")},
	}

	pk, err = CheckParamsAndKey(req)
	assert.Error(t, err)
	assert.Nil(t, pk)

	// Test with missing pubkey
	req = &Request{
		Method: "sign_event",
		Params: [][]byte{[]byte(`{"content":"test"}`)},
	}

	pk, err = CheckParamsAndKey(req)
	assert.Error(t, err)
	assert.Nil(t, pk)

	// Test with invalid pubkey
	req = &Request{
		Method: "sign_event",
		Params: [][]byte{[]byte(`{"pubkey":"invalid_pubkey"}`)},
	}

	pk, err = CheckParamsAndKey(req)
	assert.Error(t, err)
	assert.Nil(t, pk)
}

func TestHandleRequest(t *testing.T) {
	// Create a signer for testing
	signer := new(p256k.Signer)
	err := signer.Generate()
	require.NoError(t, err)

	staticSigner := NewStaticKeySigner(signer)
	require.NotNil(t, staticSigner)

	ctx := context.Bg()

	// Test with get_public_key method
	clientSigner := new(p256k.Signer)
	err = clientSigner.Generate()
	require.NoError(t, err)

	clientPubkey := clientSigner.Pub()

	// Create a test event
	ev := &event.T{
		Kind:      kind.NostrConnect,
		CreatedAt: timestamp.Now(),
		Pubkey:    clientPubkey,
		Tags:      tags.New(tag.New("p", hex.Enc(signer.Pub()))),
	}

	// Sign the event
	err = ev.Sign(clientSigner)
	require.NoError(t, err)

	// Create a session for the client
	session, err := staticSigner.getOrCreateSession(clientPubkey)
	require.NoError(t, err)

	// Create a request
	reqData := `{"id":"1","method":"get_public_key","params":[]}`
	encryptedContent, err := session.encryptRequest([]byte(reqData))
	require.NoError(t, err)

	// Update the event content
	ev.Content = encryptedContent

	// Handle the request
	req, resp, eventResponse, err := staticSigner.HandleRequest(ctx, ev)
	require.NoError(t, err)
	require.NotNil(t, req)
	require.NotNil(t, resp)
	require.NotNil(t, eventResponse)

	assert.Equal(t, "1", req.ID)
	assert.Equal(t, "get_public_key", req.Method)
	assert.Equal(t, "1", resp.ID)
	assert.NotEmpty(t, resp.Result)
	assert.Empty(t, resp.Error)
}

// Helper method to encrypt a request for testing
func (s *Session) encryptRequest(reqData []byte) ([]byte, error) {
	if s.ConversationKey != nil {
		return encryption.Encrypt(reqData, s.ConversationKey)
	}
	return encryption.EncryptNip4(reqData, s.SharedKey)
}