package peer_test

import (
	"encoding/json"
	"testing"

	"cloud.o-forge.io/core/oc-lib/models/peer"
	"cloud.o-forge.io/core/oc-lib/tools"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
)

// MockHTTPCaller mocks tools.HTTPCaller
type MockHTTPCaller struct {
	mock.Mock
	URLS map[tools.DataType]map[tools.METHOD]string
}

func (c *MockHTTPCaller) GetUrls() map[tools.DataType]map[tools.METHOD]string {
	return c.URLS
}

func (m *MockHTTPCaller) CallPost(url, token string, body interface{}, types ...string) ([]byte, error) {
	args := m.Called(url, token, body)
	return args.Get(0).([]byte), args.Error(1)
}

func (m *MockHTTPCaller) CallGet(url, token string, types ...string) ([]byte, error) {
	args := m.Called(url, token)
	return args.Get(0).([]byte), args.Error(1)
}

func (m *MockHTTPCaller) CallDelete(url, token string) ([]byte, error) {
	args := m.Called(url, token)
	return args.Get(0).([]byte), args.Error(1)
}

func TestLaunchPeerExecution_PeerNotReachable(t *testing.T) {
	cache := &peer.PeerCache{}
	caller := &MockHTTPCaller{
		URLS: map[tools.DataType]map[tools.METHOD]string{
			tools.PEER: {
				tools.POST: "/execute/:id",
			},
		},
	}
	exec, err := cache.LaunchPeerExecution("peer-id", "data-id", tools.PEER, tools.POST, map[string]string{"a": "b"}, caller)
	assert.Nil(t, exec)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "not reachable")
}

func TestExecSuccess(t *testing.T) {
	cache := &peer.PeerCache{}
	caller := &MockHTTPCaller{}
	url := "http://mockpeer/resource"
	response := map[string]interface{}{"result": "ok"}
	data, _ := json.Marshal(response)

	caller.On("CallPost", url, "", mock.Anything).Return(data, nil)
	err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
	assert.NoError(t, err)
	caller.AssertExpectations(t)
}

func TestExecReturnsErrorField(t *testing.T) {
	cache := &peer.PeerCache{}
	caller := &MockHTTPCaller{}
	url := "http://mockpeer/resource"
	response := map[string]interface{}{"error": "something failed"}
	data, _ := json.Marshal(response)

	caller.On("CallPost", url, "", mock.Anything).Return(data, nil)
	err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
	assert.Error(t, err)
	assert.Equal(t, "something failed", err.Error())
}

func TestExecInvalidJSON(t *testing.T) {
	cache := &peer.PeerCache{}
	caller := &MockHTTPCaller{}
	url := "http://mockpeer/resource"
	caller.On("CallPost", url, "", mock.Anything).Return([]byte("{invalid json}"), nil)
	err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "invalid character")
}

type mockAccessor struct {
	loadOne   func(string) (interface{}, int, error)
	updateOne func(interface{}, string) error
}

func (m *mockAccessor) LoadOne(id string) (interface{}, int, error) {
	return m.loadOne(id)
}

func (m *mockAccessor) UpdateOne(i interface{}, id string) error {
	return m.updateOne(i, id)
}