package test

import (
	"RenewCMS/internal/domain/role"
	"slices"
)

const (
	ownerRoleID  uint32 = 1
	adminRoleID  uint32 = 2
	writerRoleID uint32 = 3
)

type mockRoleRepo struct {
	roles  map[uint32]role.Role
	nextID uint32
	fail   failSwitch
}

func newMockRoleRepo() *mockRoleRepo {
	return &mockRoleRepo{roles: map[uint32]role.Role{}}
}

func newSeededMockRoleRepo() *mockRoleRepo {
	repo := newMockRoleRepo()
	for _, builtIn := range role.BuiltInRoles() {
		_, _ = repo.Create(builtIn)
	}
	return repo
}

func (m *mockRoleRepo) byName(name string) role.Role {
	found, _ := m.GetByName(name)
	return found
}

func (m *mockRoleRepo) sortedIDs() []uint32 {
	ids := make([]uint32, 0, len(m.roles))
	for id := range m.roles {
		ids = append(ids, id)
	}
	slices.Sort(ids)
	return ids
}

func (m *mockRoleRepo) List() ([]role.Role, error) {
	if err := m.fail.trigger("List"); err != nil {
		return nil, err
	}
	listed := []role.Role{}
	for _, id := range m.sortedIDs() {
		listed = append(listed, m.roles[id])
	}
	return listed, nil
}

func (m *mockRoleRepo) Get(id uint32) (role.Role, error) {
	if err := m.fail.trigger("Get"); err != nil {
		return role.Role{}, err
	}
	found, ok := m.roles[id]
	if !ok {
		return role.Role{}, role.ErrRoleNotFound
	}
	return found, nil
}

func (m *mockRoleRepo) GetByName(name string) (role.Role, error) {
	if err := m.fail.trigger("GetByName"); err != nil {
		return role.Role{}, err
	}
	var match *role.Role
	for _, id := range m.sortedIDs() {
		candidate := m.roles[id]
		if candidate.Name == name && (match == nil || candidate.BuiltIn && !match.BuiltIn) {
			match = &candidate
		}
	}
	if match == nil {
		return role.Role{}, role.ErrRoleNotFound
	}
	return *match, nil
}

func (m *mockRoleRepo) ListGrants(roleID uint32) ([]role.Grant, error) {
	if err := m.fail.trigger("ListGrants"); err != nil {
		return nil, err
	}
	found, ok := m.roles[roleID]
	if !ok {
		return nil, role.ErrRoleNotFound
	}
	return slices.Clone(found.Grants), nil
}

func (m *mockRoleRepo) Create(created role.Role) (role.Role, error) {
	if err := m.fail.trigger("Create"); err != nil {
		return role.Role{}, err
	}
	m.nextID++
	created.ID = m.nextID
	m.roles[created.ID] = created
	return created, nil
}

func (m *mockRoleRepo) Save(saved role.Role) (role.Role, error) {
	if err := m.fail.trigger("Save"); err != nil {
		return role.Role{}, err
	}
	stored, ok := m.roles[saved.ID]
	if !ok {
		return role.Role{}, role.ErrRoleNotFound
	}
	if stored.Version != saved.Version {
		return role.Role{}, role.ErrRoleConflict
	}
	stored.Name = saved.Name
	stored.Description = saved.Description
	stored.Version++
	stored.Grants = slices.Clone(saved.Grants)
	m.roles[saved.ID] = stored
	return stored, nil
}

var _ role.Repository = &mockRoleRepo{}