package msgdata

import (
	"testing"

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

var (
	defaultReqMsgID     = "abcd"
	defaultResponseData = ResponseData{
		Type:      "Output",
		ExitCode:  0,
		Output:    "hello\n",
		TimeStamp: "01-01-2023 00:00:00",
		Duration:  0.1,
	}
	defaultAttr = GeneralAttributes{
		BannerID:   "banner",
		StoreID:    "store",
		TerminalID: "terminal",
		SessionID:  "orderingKey",
		Identity:   "identity",
		Version:    "1.0",
		Signature:  "signature",
	}
	defaultAttrMap = map[string]string{
		"bannerId":             "banner",
		"storeId":              "store",
		"terminalId":           "terminal",
		"sessionId":            "orderingKey",
		"identity":             "identity",
		"version":              "1.0",
		"signature":            "signature",
		"request-message-uuid": defaultReqMsgID,
		"commandId":            defaultComID,
	}
	defaultResponseAttr = ResponseAttributes{
		GeneralAttributes: defaultAttr,
		ReqMsgID:          defaultReqMsgID,
	}
	defaultResponseDataJSON = []byte(`
{
	"type": "Output",
	"exitCode": 0,
	"output": "hello\n",
	"timestamp": "01-01-2023 00:00:00",
	"duration": 0.1
}`)
	defaultJSON = `
	{
		"data": {
			"type": "Output",
			"exitCode": 0,
			"output": "hello\n",
			"timestamp": "01-01-2023 00:00:00",
			"duration": 0.1
		},
		"attributes": {
			"bannerId": "banner",
			"storeId": "store",
			"terminalId": "terminal",
			"sessionId": "orderingKey",
			"identity": "identity",
			"version": "1.0",
			"signature": "signature",
			"request-message-uuid": "abcd"
		}
	}`
)

func TestSuccessNewCommandResponse(t *testing.T) {
	expected := &commandResponse{
		data:       defaultResponseData,
		attributes: defaultResponseAttr,
	}
	resp, err := NewCommandResponse(defaultResponseDataJSON, defaultAttrMap)
	assert.NoError(t, err)
	assert.Equal(t, expected, resp)
}

func TestFailNewCommandResponse(t *testing.T) {
	resp, err := NewCommandResponse(nil, defaultAttrMap)
	assert.Error(t, err)
	assert.Nil(t, resp)

	resp, err = NewCommandResponse(defaultResponseDataJSON, nil)
	assert.Error(t, err)
	assert.Nil(t, resp)
}

func TestAttrValidate(t *testing.T) {
	attr, _ := newGeneralAttributes(defaultAttrMap)
	assert.Len(t, attr.validate(make([]error, 0)), 0)

	badAttr := GeneralAttributes{}
	assert.Len(t, badAttr.validate(make([]error, 0)), 5)
}

func TestCommandResponseValidate(t *testing.T) {
	resp := commandResponse{
		data:       defaultResponseData,
		attributes: defaultResponseAttr,
	}
	assert.NoError(t, resp.validate())

	badResp := commandResponse{}
	assert.Len(t, badResp.validate(), 7)
}

func TestCommandResponseMarshalJSON(t *testing.T) {
	resp := commandResponse{
		data:       defaultResponseData,
		attributes: defaultResponseAttr,
	}

	expected := defaultJSON
	data, err := resp.MarshalJSON()
	assert.NoError(t, err)
	assert.JSONEq(t, expected, string(data))
}

func TestGettersReturn(t *testing.T) {
	req := commandRequest{
		data:       defaultRequestData,
		attributes: defaultRequestAttr,
	}
	resp := commandResponse{
		data:       defaultResponseData,
		attributes: defaultResponseAttr,
	}

	reqAttributes := req.Attributes()
	reqData := req.Data()
	respAttributes := resp.Attributes()
	respData := resp.Data()

	assert.Equal(t, req.attributes, reqAttributes)
	assert.Equal(t, req.data, reqData)
	assert.Equal(t, resp.attributes, respAttributes)
	assert.Equal(t, resp.data, respData)
}

func TestGettersAreCopies(t *testing.T) {
	req := commandRequest{
		data:       defaultRequestData,
		attributes: defaultRequestAttr,
	}
	resp := commandResponse{
		data:       defaultResponseData,
		attributes: defaultResponseAttr,
	}

	replacement := "something else"

	reqAttributes := req.Attributes()
	reqAttributes.BannerID = replacement

	reqData := req.Data()
	reqData.Command = replacement

	respAttributes := resp.Attributes()
	respAttributes.BannerID = replacement

	respData := resp.Data()
	respData.Output = replacement

	assert.NotEqual(t, req.attributes, reqAttributes)
	assert.NotEqual(t, req.data, reqData)
	assert.NotEqual(t, resp.attributes, respAttributes)
	assert.NotEqual(t, resp.data, respData)
}