package kind

import (
	"smesh.lol/pkg/nostr/ints"
	"smesh.lol/pkg/lol/chk"
	"smesh.lol/pkg/lol/errorf"
)

type S struct {
	K []*K
}

func NewS(k ...*K) *S { return &S{k} }

func NewWithCap(c int) *S { return &S{[]*K{:0:c}} }

func FromIntSlice(is []int) (k *S) {
	k = &S{}
	for i := range is {
		k.K = append(k.K, New(uint16(is[i])))
	}
	return
}

func (k *S) Len() int {
	if k == nil {
		return 0
	}
	return len(k.K)
}

func (k *S) Less(i, j int) bool { return k.K[i].K < k.K[j].K }

func (k *S) Swap(i, j int) {
	k.K[i].K, k.K[j].K = k.K[j].K, k.K[i].K
}

func (k *S) ToUint16() (o []uint16) {
	for i := range k.K {
		o = append(o, k.K[i].ToU16())
	}
	return
}

func (k *S) Clone() (c *S) {
	c = &S{K: []*K{:len(k.K)}}
	for i := range k.K {
		c.K[i] = k.K[i]
	}
	return
}

func (k *S) Contains(s uint16) bool {
	for i := range k.K {
		if k.K[i].Equal(s) {
			return true
		}
	}
	return false
}

func (k *S) Equals(t1 *S) bool {
	if len(k.K) != len(t1.K) {
		return false
	}
	for i := range k.K {
		if k.K[i] != t1.K[i] {
			return false
		}
	}
	return true
}

func (k *S) Marshal(dst []byte) (b []byte) {
	b = dst
	b = append(b, '[')
	for i := range k.K {
		b = k.K[i].Marshal(b)
		if i != len(k.K)-1 {
			b = append(b, ',')
		}
	}
	b = append(b, ']')
	return
}

func (k *S) Unmarshal(b []byte) (r []byte, err error) {
	r = b
	var openedBracket bool
	for ; len(r) > 0; r = r[1:] {
		if !openedBracket && r[0] == '[' {
			openedBracket = true
			continue
		} else if openedBracket {
			if r[0] == ']' {
				return
			} else if r[0] == ',' {
				continue
			}
			kk := ints.New(0)
			if r, err = kk.Unmarshal(r); chk.E(err) {
				return
			}
			k.K = append(k.K, New(kk.Uint16()))
			if r[0] == ']' {
				r = r[1:]
				return
			}
		}
	}
	if !openedBracket {
		return nil, errorf.E([]byte("kinds: failed to unmarshal\n%s\n%s\n%s"), k, b, r)
	}
	return
}

func (k *S) IsPrivileged() bool {
	for i := range k.K {
		if IsPrivileged(k.K[i].K) {
			return true
		}
	}
	return false
}