package protocol

import (
	"bytes"
	"testing"

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

	"hash-of-wisdom/internal/pow/challenge"
	"hash-of-wisdom/internal/quotes"
)

func TestSymmetricEncoding_ChallengeRequest(t *testing.T) {
	// Create a challenge request
	req := &ChallengeRequest{}

	// Encode it
	var buf bytes.Buffer
	err := req.Encode(&buf)
	require.NoError(t, err)

	// Decode it back
	decoder := NewMessageDecoder()
	msg, err := decoder.Decode(&buf)
	require.NoError(t, err)
	assert.Equal(t, ChallengeRequestType, msg.Type)
	assert.Equal(t, uint32(0), msg.PayloadLength)

	// Decode the request payload
	decodedReq := &ChallengeRequest{}
	err = decodedReq.Decode(msg.PayloadStream)
	require.NoError(t, err)
}

func TestSymmetricEncoding_SolutionRequest(t *testing.T) {
	// Create a solution request
	req := &SolutionRequest{
		Challenge: challenge.Challenge{
			Timestamp:  1640995200,
			Difficulty: 4,
			Resource:   "quotes",
			Random:     []byte("test"),
			HMAC:       []byte("test"),
		},
		Nonce: 12345,
	}

	// Encode it
	var buf bytes.Buffer
	err := req.Encode(&buf)
	require.NoError(t, err)

	// Decode it back
	decoder := NewMessageDecoder()
	msg, err := decoder.Decode(&buf)
	require.NoError(t, err)
	assert.Equal(t, SolutionRequestType, msg.Type)
	assert.Greater(t, msg.PayloadLength, uint32(0))

	// Decode the request payload
	decodedReq := &SolutionRequest{}
	err = decodedReq.Decode(msg.PayloadStream)
	require.NoError(t, err)
	assert.Equal(t, req.Nonce, decodedReq.Nonce)
	assert.Equal(t, req.Challenge.Timestamp, decodedReq.Challenge.Timestamp)
}

func TestSymmetricEncoding_ChallengeResponse(t *testing.T) {
	// Create a challenge response
	resp := &ChallengeResponse{
		Challenge: &challenge.Challenge{
			Timestamp:  1640995200,
			Difficulty: 4,
			Resource:   "quotes",
			Random:     []byte("test"),
			HMAC:       []byte("test"),
		},
	}

	// Encode it
	var buf bytes.Buffer
	err := resp.Encode(&buf)
	require.NoError(t, err)

	// Decode it back
	decoder := NewMessageDecoder()
	msg, err := decoder.Decode(&buf)
	require.NoError(t, err)
	assert.Equal(t, ChallengeResponseType, msg.Type)
	assert.Greater(t, msg.PayloadLength, uint32(0))

	// Decode the response payload
	decodedResp := &ChallengeResponse{}
	err = decodedResp.Decode(msg.PayloadStream)
	require.NoError(t, err)
	assert.Equal(t, resp.Challenge.Timestamp, decodedResp.Challenge.Timestamp)
	assert.Equal(t, resp.Challenge.Difficulty, decodedResp.Challenge.Difficulty)
}

func TestSymmetricEncoding_SolutionResponse(t *testing.T) {
	// Create a solution response
	resp := &SolutionResponse{
		Quote: &quotes.Quote{
			Text:   "Test quote",
			Author: "Test Author",
		},
	}

	// Encode it
	var buf bytes.Buffer
	err := resp.Encode(&buf)
	require.NoError(t, err)

	// Decode it back
	decoder := NewMessageDecoder()
	msg, err := decoder.Decode(&buf)
	require.NoError(t, err)
	assert.Equal(t, QuoteResponseType, msg.Type)
	assert.Greater(t, msg.PayloadLength, uint32(0))

	// Decode the response payload
	decodedResp := &SolutionResponse{}
	err = decodedResp.Decode(msg.PayloadStream)
	require.NoError(t, err)
	assert.Equal(t, resp.Quote.Text, decodedResp.Quote.Text)
	assert.Equal(t, resp.Quote.Author, decodedResp.Quote.Author)
}

func TestSymmetricEncoding_ErrorResponse(t *testing.T) {
	// Create an error response
	resp := &ErrorResponse{
		Code:    "TEST_ERROR",
		Message: "Test error message",
		Details: map[string]string{"key": "value"},
	}

	// Encode it
	var buf bytes.Buffer
	err := resp.Encode(&buf)
	require.NoError(t, err)

	// Decode it back
	decoder := NewMessageDecoder()
	msg, err := decoder.Decode(&buf)
	require.NoError(t, err)
	assert.Equal(t, ErrorResponseType, msg.Type)
	assert.Greater(t, msg.PayloadLength, uint32(0))

	// Decode the response payload
	decodedResp := &ErrorResponse{}
	err = decodedResp.Decode(msg.PayloadStream)
	require.NoError(t, err)
	assert.Equal(t, resp.Code, decodedResp.Code)
	assert.Equal(t, resp.Message, decodedResp.Message)
	assert.Equal(t, resp.Details, decodedResp.Details)
}