package room

import (
	"encoding/json"
	"fmt"
	"strings"
)

type RoomRole int16

const (
	RoleCreator RoomRole = 1
	RoleAdmin   RoomRole = 2
	RoleMember  RoomRole = 3
	RoleGuest   RoomRole = 4
)

func (r RoomRole) String() string {
	switch r {
	case RoleCreator:
		return "creator"
	case RoleAdmin:
		return "admin"
	case RoleMember:
		return "member"
	case RoleGuest:
		return "guest"
	default:
		return fmt.Sprintf("role_%d", int(r))
	}
}

func ParseRoomRole(s string) (RoomRole, error) {
	switch strings.ToLower(strings.TrimSpace(s)) {
	case "creator", "owner":
		return RoleCreator, nil
	case "admin":
		return RoleAdmin, nil
	case "member", "publisher", "viewer":
		return RoleMember, nil
	case "guest":
		return RoleGuest, nil
	default:
		return 0, fmt.Errorf("unknown role %q", s)
	}
}

func (r RoomRole) IsPrivileged() bool { return r == RoleCreator || r == RoleAdmin }
func (r RoomRole) Rank() int {
	switch r {
	case RoleCreator:
		return 100
	case RoleAdmin:
		return 80
	case RoleMember:
		return 50
	case RoleGuest:
		return 10
	default:
		return 0
	}
}

func (r RoomRole) MarshalJSON() ([]byte, error) {
	return json.Marshal(r.String())
}

func (r *RoomRole) UnmarshalJSON(data []byte) error {
	if len(data) == 0 || string(data) == "null" {
		*r = 0
		return nil
	}
	var s string
	if err := json.Unmarshal(data, &s); err == nil {
		parsed, err := ParseRoomRole(s)
		if err != nil {
			return err
		}
		*r = parsed
		return nil
	}
	var n int16
	if err := json.Unmarshal(data, &n); err == nil {
		*r = RoomRole(n)
		return nil
	}
	return fmt.Errorf("invalid RoomRole %s", string(data))
}

func (r RoomRole) CanManage(target RoomRole) bool {
	if r == RoleCreator {
		return true
	}
	if r == RoleAdmin && target != RoleCreator {
		return true
	}
	return false
}

type MemberStatus int16

const (
	MemberActive   MemberStatus = 1
	MemberBanned   MemberStatus = 2
	MemberPending  MemberStatus = 3
	MemberKicked   MemberStatus = 4
)


func (s MemberStatus) MarshalJSON() ([]byte, error) {
	return json.Marshal(s.String())
}

func (s *MemberStatus) UnmarshalJSON(data []byte) error {
	if len(data) == 0 || string(data) == "null" {
		*s = 0
		return nil
	}
	var str string
	if err := json.Unmarshal(data, &str); err == nil {
		switch strings.ToLower(strings.TrimSpace(str)) {
		case "active":
			*s = MemberActive
		case "banned":
			*s = MemberBanned
		case "pending":
			*s = MemberPending
		case "kicked":
			*s = MemberKicked
		default:
			return fmt.Errorf("unknown status %q", str)
		}
		return nil
	}
	var n int16
	if err := json.Unmarshal(data, &n); err == nil {
		*s = MemberStatus(n)
		return nil
	}
	return fmt.Errorf("invalid MemberStatus %s", string(data))
}

func (s MemberStatus) String() string {
	switch s {
	case MemberActive:
		return "active"
	case MemberBanned:
		return "banned"
	case MemberPending:
		return "pending"
	case MemberKicked:
		return "kicked"
	default:
		return fmt.Sprintf("status_%d", int(s))
	}
}