package peer_test

import (
	"testing"

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

	"cloud.o-forge.io/core/oc-lib/dbs"
	"cloud.o-forge.io/core/oc-lib/models/peer"
	"cloud.o-forge.io/core/oc-lib/models/utils"
)

type MockAccessor struct {
	mock.Mock
	utils.AbstractAccessor
}

func (m *MockAccessor) DeleteOne(id string) (utils.DBObject, int, error) {
	args := m.Called(id)
	return args.Get(0).(utils.DBObject), args.Int(1), args.Error(2)
}

func (m *MockAccessor) UpdateOne(set utils.DBObject, id string) (utils.DBObject, int, error) {
	args := m.Called(set, id)
	return args.Get(0).(utils.DBObject), args.Int(1), args.Error(2)
}

func (m *MockAccessor) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
	args := m.Called(data)
	return args.Get(0).(utils.DBObject), args.Int(1), args.Error(2)
}

func (m *MockAccessor) LoadOne(id string) (utils.DBObject, int, error) {
	args := m.Called(id)
	return args.Get(0).(utils.DBObject), args.Int(1), args.Error(2)
}

func (m *MockAccessor) LoadAll(isDraft bool) ([]utils.ShallowDBObject, int, error) {
	args := m.Called(isDraft)
	return args.Get(0).([]utils.ShallowDBObject), args.Int(1), args.Error(2)
}

func (m *MockAccessor) Search(filters *dbs.Filters, search string, isDraft bool) ([]utils.ShallowDBObject, int, error) {
	args := m.Called(filters, search, isDraft)
	return args.Get(0).([]utils.ShallowDBObject), args.Int(1), args.Error(2)
}

func newTestPeer() *peer.Peer {
	return &peer.Peer{
		Url:           "http://localhost",
		WalletAddress: "0x123",
		PublicKey:     "pubkey",
		State:         peer.SELF,
	}
}

func TestDeleteOne_UsingMock(t *testing.T) {
	mockAcc := new(MockAccessor)
	mockAcc.On("DeleteOne", "id").Return(newTestPeer(), 200, nil)

	obj, code, err := mockAcc.DeleteOne("id")
	assert.NoError(t, err)
	assert.Equal(t, 200, code)
	assert.NotNil(t, obj)
	mockAcc.AssertExpectations(t)
}

func TestUpdateOne_UsingMock(t *testing.T) {
	mockAcc := new(MockAccessor)
	peerObj := newTestPeer()
	mockAcc.On("UpdateOne", peerObj, "id").Return(peerObj, 200, nil)

	obj, code, err := mockAcc.UpdateOne(peerObj, "id")
	assert.NoError(t, err)
	assert.Equal(t, 200, code)
	assert.Equal(t, peerObj, obj)
	mockAcc.AssertExpectations(t)
}

func TestStoreOne_UsingMock(t *testing.T) {
	mockAcc := new(MockAccessor)
	peerObj := newTestPeer()
	mockAcc.On("StoreOne", peerObj).Return(peerObj, 200, nil)

	obj, code, err := mockAcc.StoreOne(peerObj)
	assert.NoError(t, err)
	assert.Equal(t, 200, code)
	assert.Equal(t, peerObj, obj)
	mockAcc.AssertExpectations(t)
}

func TestLoadOne_UsingMock(t *testing.T) {
	mockAcc := new(MockAccessor)
	mockAcc.On("LoadOne", "test-id").Return(newTestPeer(), 200, nil)

	obj, code, err := mockAcc.LoadOne("test-id")
	assert.NoError(t, err)
	assert.Equal(t, 200, code)
	assert.NotNil(t, obj)
	mockAcc.AssertExpectations(t)
}

func TestLoadAll_UsingMock(t *testing.T) {
	mockAcc := new(MockAccessor)
	expected := []utils.ShallowDBObject{newTestPeer()}
	mockAcc.On("LoadAll", false).Return(expected, 200, nil)

	objs, code, err := mockAcc.LoadAll(false)
	assert.NoError(t, err)
	assert.Equal(t, 200, code)
	assert.Equal(t, expected, objs)
	mockAcc.AssertExpectations(t)
}

func TestSearch_UsingMock(t *testing.T) {
	mockAcc := new(MockAccessor)
	filters := &dbs.Filters{}
	expected := []utils.ShallowDBObject{newTestPeer()}
	mockAcc.On("Search", filters, "test", false).Return(expected, 200, nil)

	objs, code, err := mockAcc.Search(filters, "test", false)
	assert.NoError(t, err)
	assert.Equal(t, 200, code)
	assert.Equal(t, expected, objs)
	mockAcc.AssertExpectations(t)
}