//go:generate go run gen/mus.go
package foo

type Foo struct {
  num int `mus:"validator.Positive"` // Private fields are supported
  // too. It will be checked with Positive validator while unmarshalling.
  arr []int `mus:",,validator.Positive"` // Every slice element will be checked
  // with Positive validator.
  Alias StringAlias // Alias types are supported too.
  Bool bool     `mus:"-"` // This field will be skiped.
}

type StringAlias string

package validator

import "errors"

var ErrNegative error = errors.New("negative")

func Positive(n int) error {
  if n < 0 {
    return ErrNegative
  }
  return nil
}

//go:build ignore

package main

import (
  "foo"
  "reflect"

  "github.com/ymz-ncnk/musgo/v2"
)

func main() {
  // MusGo can generate code for struct or alias types.
  musGo, err := musgo.New()
  if err != nil {
    panic(err)
  }
  // You should "Generate" for all involved custom types.
  unsafe := false // To generate safe code.
  var alias foo.StringAlias
  // Alias types don't support tags, so to set up validator we use
  // GenerateAliasAs() method.
  conf := musgo.DefAliasConf
  conf.MaxLength = 5 // Restricts length of StringAlias values to 5 characters.
  err = musGo.GenerateAliasAs(reflect.TypeOf(alias), conf)
  if err != nil {
    panic(err)
  }
  // reflect.Type could be created without the explicit variable.
  err = musGo.Generate(reflect.TypeOf((*foo.Foo)(nil)).Elem(), unsafe)
  if err != nil {
    panic(err)
  }
}

package foo

import (
  "foo/validator"
  "reflect"
  "testing"

  "github.com/ymz-ncnk/muserrs"
)

func TestFooSerialization(t *testing.T) {
  foo := Foo{
    num:   5,
    arr:   []int{4, 2},
    Alias: StringAlias("hello"),
    Bool:  true,
  }
  buf := make([]byte, foo.SizeMUS())
  foo.MarshalMUS(buf)

  afoo := Foo{}
  _, err := afoo.UnmarshalMUS(buf)
  if err != nil {
    t.Error(err)
  }
  foo.Bool = false
  if !reflect.DeepEqual(foo, afoo) {
    t.Error("something went wrong")
  }
}

func TestFooValidation(t *testing.T) {
  t.Run("Validator", func(t *testing.T) {
    var (
      foo = Foo{
        num:   -11,
        arr:   []int{1, 2},
        Alias: "hello",
      }
      want = muserrs.NewFieldError("num", validator.ErrNegative)
    )
    buf := make([]byte, foo.SizeMUS())
    foo.MarshalMUS(buf)

    afoo := Foo{}
    _, err := afoo.UnmarshalMUS(buf)
    if err == nil {
      t.Error("validation error expected")
    }
    if err.Error() != want.Error() {
      t.Fatalf("unexpected error, want '%v' actual '%v'", want, err)
    }
  })

  t.Run("Element validator", func(t *testing.T) {
    var (
      foo = Foo{
        num:   3,
        arr:   []int{1, -12, 2},
        Alias: "hello",
      }
      want = muserrs.NewFieldError("arr", muserrs.NewSliceError(1,
        validator.ErrNegative))
    )
    buf := make([]byte, foo.SizeMUS())
    foo.MarshalMUS(buf)

    afoo := Foo{}
    _, err := afoo.UnmarshalMUS(buf)
    if err == nil {
      t.Error("validation error expected")
    }
    if err.Error() != want.Error() {
      t.Fatalf("unexpected error, want '%v' actual '%v'", want, err)
    }
  })

  t.Run("Max length", func(t *testing.T) {
    var (
      foo = Foo{
        num:   8,
        arr:   []int{1, 2},
        Alias: "hello world",
      }
      want = muserrs.NewFieldError("Alias", muserrs.ErrMaxLengthExceeded)
    )
    buf := make([]byte, foo.SizeMUS())
    foo.MarshalMUS(buf)

    afoo := Foo{}
    _, err := afoo.UnmarshalMUS(buf)
    if err == nil {
      t.Error("validation error expected")
    }
    if err.Error() != want.Error() {
      t.Fatalf("unexpected error, want '%v' actual '%v'", want, err)
    }
  })
}

...
buf := make([]byte, FixedLength)
for foo := range foos {
  if foo.Size() > len(buf) {
    return errors.New("buf is too small")
  }
  i = foo.MarshalMUS(buf)
  err = handle(buf[:i])
  ...
}

...
defer func() {
  if r := recover(); r != nil {
    return errors.New("buf is too small")
  }
}()
buf := make([]byte, FixedLength)
for _, foo := range foos {
  i = foo.MarshalMUS(buf)
  err = handle(buf[:i])
  ...
}

type PtrInt struct {
  Value *int
}

var ptr PtrInt
// Buf will not equal to an empty slice here.
buf := make([]byte, ptr.SizeMUS())
ptr.MarshalMUS(buf) // buf == []{0}

...
var buf []byte
if ptr.Value == nil {
  buf = []byte{}
} else {
  buf = make([]byte, ptr.SizeMUS())
  ptr.MarshalMUS(buf)
}
persist(buf)

...
var ptr PtrInt
if len(buf) != 0 {
  _, err = ptr.UnamrshalMUS(buf)
  ...
}

// Validator for the field.
type Foo struct {
  Field string `mus:"StrValidator"`
}

func StrValidator(str string) error {...}

// ElemValidator for the slice field.
type Bar struct {
  Field []string `mus:",,StrValidator"`
}

// KeyValidator for the map field.
type Zoo struct {
  Field map[string]int `mus:",,,StrValidator"`
}

// Validator for the field of a custom pointer type.
type Far struct {
  Field *Foo `mus:FooValidator`
}

func FooValidator(foo *Foo) error {...}

// Validator for the alias field.
type Ror []string

type Pac struct {
  Field Ror `mus:RorValidator`  // you can't set MaxLength or 
  // ElemValidator here, they should be applied for the Ror type.
}

func RorValidator(ror Ror) error {...}

// Set up the Raw encoding without a validator for the field.
type Foo struct {
  Field uint64 `mus:"#raw"`
}

// Set up the validator and Raw encoding for the field.
type Foo struct {
  Field uint64 `mus:"Positive#raw"`
}