package models_test

import (
	"errors"
	"testing"

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

// --- Mock Definitions ---

type MockDBObject struct {
	mock.Mock
}

func (m *MockAccessor) GetLogger() *zerolog.Logger {
	return nil
}
func (m *MockAccessor) GetGroups() []string {
	return []string{}
}

func (m *MockAccessor) GetCaller() *tools.HTTPCaller {
	return nil
}

func (m *MockDBObject) GenerateID()        { m.Called() }
func (m *MockDBObject) StoreDraftDefault() { m.Called() }
func (m *MockDBObject) UpToDate(user, peer string, create bool) {
	m.Called(user, peer, create)
}
func (m *MockDBObject) VerifyAuth(req *tools.APIRequest) bool {
	args := m.Called(req)
	return args.Bool(0)
}
func (m *MockDBObject) CanDelete() bool {
	args := m.Called()
	return args.Bool(0)
}
func (m *MockDBObject) CanUpdate(set utils.DBObject) (bool, utils.DBObject) {
	args := m.Called(set)
	return args.Bool(0), args.Get(1).(utils.DBObject)
}
func (m *MockDBObject) IsDrafted() bool {
	args := m.Called()
	return args.Bool(0)
}
func (m *MockDBObject) Serialize(obj utils.DBObject) map[string]interface{} {
	args := m.Called(obj)
	return args.Get(0).(map[string]interface{})
}
func (m *MockDBObject) Deserialize(mdata map[string]interface{}, obj utils.DBObject) utils.DBObject {
	args := m.Called(mdata, obj)
	return args.Get(0).(utils.DBObject)
}
func (m *MockDBObject) GetID() string {
	args := m.Called()
	return args.String(0)
}
func (m *MockDBObject) GetName() string {
	args := m.Called()
	return args.String(0)
}

type MockAccessor struct {
	mock.Mock
}

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) 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) 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) CopyOne(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) 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) ShouldVerifyAuth() bool {
	args := m.Called()
	return args.Bool(0)
}
func (m *MockAccessor) GetRequest() *tools.APIRequest {
	args := m.Called()
	return args.Get(0).(*tools.APIRequest)
}
func (m *MockAccessor) GetType() tools.DataType {
	args := m.Called()
	return args.Get(0).(tools.DataType)
}
func (m *MockAccessor) Search(filters *dbs.Filters, s string, d bool) ([]utils.ShallowDBObject, int, error) {
	args := m.Called(filters, s, d)
	return args.Get(0).([]utils.ShallowDBObject), args.Int(1), args.Error(2)
}

func (m *MockAccessor) GetUser() string {
	args := m.Called()
	return args.String(0)
}
func (m *MockAccessor) GetPeerID() string {
	args := m.Called()
	return args.String(0)
}

// --- Test Cases ---

func TestVerifyAccess_Authorized(t *testing.T) {
	mockObj := new(MockDBObject)
	mockAcc := new(MockAccessor)

	req := &tools.APIRequest{PeerID: "peer"}
	mockAcc.On("LoadOne", "123").Return(mockObj, 200, nil)
	mockAcc.On("ShouldVerifyAuth").Return(true)
	mockObj.On("VerifyAuth", req).Return(true)
	mockAcc.On("GetRequest").Return(req)

	err := utils.VerifyAccess(mockAcc, "123")
	assert.NoError(t, err)
}

func TestVerifyAccess_Unauthorized(t *testing.T) {
	mockObj := new(MockDBObject)
	mockAcc := new(MockAccessor)

	req := &tools.APIRequest{PeerID: "peer"}
	mockAcc.On("LoadOne", "123").Return(mockObj, 200, nil)
	mockAcc.On("ShouldVerifyAuth").Return(true)
	mockObj.On("VerifyAuth", req).Return(false)
	mockAcc.On("GetRequest").Return(req)

	err := utils.VerifyAccess(mockAcc, "123")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "not allowed")
}

func TestVerifyAccess_LoadError(t *testing.T) {
	mockAcc := new(MockAccessor)

	mockAcc.On("LoadOne", "bad-id").Return(nil, 404, errors.New("not found"))

	err := utils.VerifyAccess(mockAcc, "bad-id")
	assert.Error(t, err)
	assert.Equal(t, "not found", err.Error())
}