basedao

package basedao

import (
	"errors"
	"strings"

	"gno.land/p/moul/md"
	"gno.land/p/nt/ufmt/v0"
	"gno.land/p/samcrew/daokit"
)

// ADD MEMBER

const ActionAddMemberKind = "gno.land/p/samcrew/basedao.AddMember"

type ActionAddMember struct {
	Address address
	Roles   []string
}

func (a *ActionAddMember) String() string {
	s := "Add member " + a.Address.String()
	if len(a.Roles) != 0 {
		s += " with roles " + strings.Join(a.Roles, ", ")
	}
	return s
}

func NewAddMemberHandler(dao *DAOPrivate) daokit.ActionHandler {
	return daokit.NewActionHandler(ActionAddMemberKind, func(ipayload interface{}, _ realm) {
		payload, ok := ipayload.(*ActionAddMember)
		if !ok {
			panic(errors.New("invalid payload type"))
		}
		dao.Members.AddMember(payload.Address.String(), payload.Roles)
	})
}

func NewAddMemberAction(payload *ActionAddMember) daokit.Action {
	return daokit.NewAction(ActionAddMemberKind, payload)
}

// REMOVE MEMBER

const ActionRemoveMemberKind = "gno.land/p/samcrew/basedao.RemoveMember"

func NewRemoveMemberHandler(dao *DAOPrivate) daokit.ActionHandler {
	return daokit.NewActionHandler(ActionRemoveMemberKind, func(ipayload interface{}, _ realm) {
		addr, ok := ipayload.(address)
		if !ok {
			panic(errors.New("invalid payload type"))
		}
		dao.Members.RemoveMember(addr.String())
	})
}

func NewRemoveMemberAction(addr address) daokit.Action {
	return daokit.NewAction(ActionRemoveMemberKind, addr)
}

// ASSIGN ROLE

const ActionAssignRoleKind = "gno.land/p/samcrew/basedao.AssignRole"

type ActionAssignRole struct {
	Address address
	Role    string
}

func (a *ActionAssignRole) String() string {
	return ufmt.Sprintf("Assign role %q to user %s", a.Role, a.Address)
}

func NewAssignRoleHandler(dao *DAOPrivate) daokit.ActionHandler {
	return daokit.NewActionHandler(ActionAssignRoleKind, func(i interface{}, _ realm) {
		payload, ok := i.(*ActionAssignRole)
		if !ok {
			panic(errors.New("invalid payload type"))
		}
		dao.Members.AddRoleToMember(payload.Address.String(), payload.Role)
	})
}

func NewAssignRoleAction(payload *ActionAssignRole) daokit.Action {
	return daokit.NewAction(ActionAssignRoleKind, payload)
}

// UNASSIGN ROLE

const ActionUnassignRoleKind = "gno.land/p/samcrew/basedao.UnassignRole"

type ActionUnassignRole struct {
	Address address
	Role    string
}

func (a *ActionUnassignRole) String() string {
	return ufmt.Sprintf("Remove role %q from user %s", a.Role, a.Address)
}

func NewUnassignRoleHandler(dao *DAOPrivate) daokit.ActionHandler {
	return daokit.NewActionHandler(ActionUnassignRoleKind, func(i interface{}, _ realm) {
		payload, ok := i.(*ActionUnassignRole)
		if !ok {
			panic(errors.New("invalid payload type"))
		}
		dao.Members.RemoveRoleFromMember(payload.Address.String(), payload.Role)
	})
}

func NewUnassignRoleAction(payload *ActionUnassignRole) daokit.Action {
	return daokit.NewAction(ActionUnassignRoleKind, payload)
}

// EDIT PROFILE

const ActionEditProfileKind = "gno.land/p/samcrew/basedao.EditProfile"

type ActionEditProfile struct {
	kv [][2]string
}

func (a *ActionEditProfile) String() string {
	elems := []string{}
	for _, v := range a.kv {
		elems = append(elems, v[0]+": "+v[1])
	}
	return md.BulletList(elems)
}

func NewEditProfileAction(kv ...[2]string) daokit.Action {
	return daokit.NewAction(ActionEditProfileKind, &ActionEditProfile{kv: kv})
}

func NewEditProfileHandler(setter ProfileStringSetter, allowedFields []string) daokit.ActionHandler {
	return daokit.NewActionHandler(ActionEditProfileKind, func(i interface{}, rlm realm) {
		action, ok := i.(*ActionEditProfile)
		if !ok {
			panic(errors.New("invalid action type"))
		}
		for _, elem := range action.kv {
			k, v := elem[0], elem[1]
			if len(allowedFields) > 0 && !stringSliceContains(allowedFields, k) {
				panic(ufmt.Errorf("unauthorized field %q", k))
			}
			setter(cross(rlm), k, v)
		}
	})
}

func stringSliceContains(s []string, target string) bool {
	for _, elem := range s {
		if elem == target {
			return true
		}
	}
	return false
}