// Autogenerated Go message buffer code.
// Source: clad/cloud/token.clad
// Full command line: victor-clad/tools/message-buffers/emitters/Go_emitter.py -C src -o generated/cladgo/src clad/cloud/token.clad

package cloud

import (
  "bytes"
  "encoding/binary"
  "errors"
  "anki/clad"
  "fmt"
)

// ENUM TokenError
type TokenError uint8

const (
  TokenError_NoError TokenError = iota
  TokenError_NullToken                
  TokenError_InvalidToken             
  TokenError_Connection               
  TokenError_WrongAccount             
)

// STRUCTURE AuthRequest
type AuthRequest struct {
  SessionToken string
  ClientName string
  AppId string
}

func (a *AuthRequest) Size() uint32 {
  var result uint32
  result += 1 // SessionToken length (uint_8)
  result += uint32(len(a.SessionToken)) // uint_8 array
  result += 1 // ClientName length (uint_8)
  result += uint32(len(a.ClientName)) // uint_8 array
  result += 1 // AppId length (uint_8)
  result += uint32(len(a.AppId)) // uint_8 array
  return result
}

func (a *AuthRequest) Unpack(buf *bytes.Buffer) error {
  var SessionTokenLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &SessionTokenLen); err != nil {
    return err
  }
  a.SessionToken = string(buf.Next(int(SessionTokenLen)))
  if len(a.SessionToken) != int(SessionTokenLen) {
    return errors.New("string byte mismatch")
  }
  var ClientNameLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &ClientNameLen); err != nil {
    return err
  }
  a.ClientName = string(buf.Next(int(ClientNameLen)))
  if len(a.ClientName) != int(ClientNameLen) {
    return errors.New("string byte mismatch")
  }
  var AppIdLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &AppIdLen); err != nil {
    return err
  }
  a.AppId = string(buf.Next(int(AppIdLen)))
  if len(a.AppId) != int(AppIdLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (a *AuthRequest) Pack(buf *bytes.Buffer) error {
  if len(a.SessionToken) > 255 {
    return errors.New("max_length overflow in field SessionToken")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(a.SessionToken))); err != nil {
    return err
  }
  if _, err := buf.WriteString(a.SessionToken); err != nil {
    return err
  }
  if len(a.ClientName) > 255 {
    return errors.New("max_length overflow in field ClientName")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(a.ClientName))); err != nil {
    return err
  }
  if _, err := buf.WriteString(a.ClientName); err != nil {
    return err
  }
  if len(a.AppId) > 255 {
    return errors.New("max_length overflow in field AppId")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(a.AppId))); err != nil {
    return err
  }
  if _, err := buf.WriteString(a.AppId); err != nil {
    return err
  }
  return nil
}

func (a *AuthRequest) String() string {
  return fmt.Sprint("SessionToken: {", a.SessionToken, "} ",
    "ClientName: {", a.ClientName, "} ",
    "AppId: {", a.AppId, "}")
}


// STRUCTURE AuthResponse
type AuthResponse struct {
  AppToken string
  JwtToken string
  Error TokenError
}

func (a *AuthResponse) Size() uint32 {
  var result uint32
  result += 2 // AppToken length (uint_16)
  result += uint32(len(a.AppToken)) // uint_8 array
  result += 2 // JwtToken length (uint_16)
  result += uint32(len(a.JwtToken)) // uint_8 array
  result += 1 // Error TokenError
  return result
}

func (a *AuthResponse) Unpack(buf *bytes.Buffer) error {
  var AppTokenLen uint16
  if err := binary.Read(buf, binary.LittleEndian, &AppTokenLen); err != nil {
    return err
  }
  a.AppToken = string(buf.Next(int(AppTokenLen)))
  if len(a.AppToken) != int(AppTokenLen) {
    return errors.New("string byte mismatch")
  }
  var JwtTokenLen uint16
  if err := binary.Read(buf, binary.LittleEndian, &JwtTokenLen); err != nil {
    return err
  }
  a.JwtToken = string(buf.Next(int(JwtTokenLen)))
  if len(a.JwtToken) != int(JwtTokenLen) {
    return errors.New("string byte mismatch")
  }
  if err := binary.Read(buf, binary.LittleEndian, &a.Error); err != nil {
    return err
  }
  return nil
}

func (a *AuthResponse) Pack(buf *bytes.Buffer) error {
  if len(a.AppToken) > 65535 {
    return errors.New("max_length overflow in field AppToken")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint16(len(a.AppToken))); err != nil {
    return err
  }
  if _, err := buf.WriteString(a.AppToken); err != nil {
    return err
  }
  if len(a.JwtToken) > 65535 {
    return errors.New("max_length overflow in field JwtToken")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint16(len(a.JwtToken))); err != nil {
    return err
  }
  if _, err := buf.WriteString(a.JwtToken); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, a.Error); err != nil {
    return err
  }
  return nil
}

func (a *AuthResponse) String() string {
  return fmt.Sprint("AppToken: {", a.AppToken, "} ",
    "JwtToken: {", a.JwtToken, "} ",
    "Error: {", a.Error, "}")
}


// STRUCTURE ReassociateRequest
type ReassociateRequest struct {
  SessionToken string
  ClientName string
  AppId string
}

func (r *ReassociateRequest) Size() uint32 {
  var result uint32
  result += 1 // SessionToken length (uint_8)
  result += uint32(len(r.SessionToken)) // uint_8 array
  result += 1 // ClientName length (uint_8)
  result += uint32(len(r.ClientName)) // uint_8 array
  result += 1 // AppId length (uint_8)
  result += uint32(len(r.AppId)) // uint_8 array
  return result
}

func (r *ReassociateRequest) Unpack(buf *bytes.Buffer) error {
  var SessionTokenLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &SessionTokenLen); err != nil {
    return err
  }
  r.SessionToken = string(buf.Next(int(SessionTokenLen)))
  if len(r.SessionToken) != int(SessionTokenLen) {
    return errors.New("string byte mismatch")
  }
  var ClientNameLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &ClientNameLen); err != nil {
    return err
  }
  r.ClientName = string(buf.Next(int(ClientNameLen)))
  if len(r.ClientName) != int(ClientNameLen) {
    return errors.New("string byte mismatch")
  }
  var AppIdLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &AppIdLen); err != nil {
    return err
  }
  r.AppId = string(buf.Next(int(AppIdLen)))
  if len(r.AppId) != int(AppIdLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (r *ReassociateRequest) Pack(buf *bytes.Buffer) error {
  if len(r.SessionToken) > 255 {
    return errors.New("max_length overflow in field SessionToken")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(r.SessionToken))); err != nil {
    return err
  }
  if _, err := buf.WriteString(r.SessionToken); err != nil {
    return err
  }
  if len(r.ClientName) > 255 {
    return errors.New("max_length overflow in field ClientName")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(r.ClientName))); err != nil {
    return err
  }
  if _, err := buf.WriteString(r.ClientName); err != nil {
    return err
  }
  if len(r.AppId) > 255 {
    return errors.New("max_length overflow in field AppId")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(r.AppId))); err != nil {
    return err
  }
  if _, err := buf.WriteString(r.AppId); err != nil {
    return err
  }
  return nil
}

func (r *ReassociateRequest) String() string {
  return fmt.Sprint("SessionToken: {", r.SessionToken, "} ",
    "ClientName: {", r.ClientName, "} ",
    "AppId: {", r.AppId, "}")
}


// STRUCTURE SecondaryAuthRequest
type SecondaryAuthRequest struct {
  SessionToken string
  ClientName string
  AppId string
}

func (s *SecondaryAuthRequest) Size() uint32 {
  var result uint32
  result += 1 // SessionToken length (uint_8)
  result += uint32(len(s.SessionToken)) // uint_8 array
  result += 1 // ClientName length (uint_8)
  result += uint32(len(s.ClientName)) // uint_8 array
  result += 1 // AppId length (uint_8)
  result += uint32(len(s.AppId)) // uint_8 array
  return result
}

func (s *SecondaryAuthRequest) Unpack(buf *bytes.Buffer) error {
  var SessionTokenLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &SessionTokenLen); err != nil {
    return err
  }
  s.SessionToken = string(buf.Next(int(SessionTokenLen)))
  if len(s.SessionToken) != int(SessionTokenLen) {
    return errors.New("string byte mismatch")
  }
  var ClientNameLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &ClientNameLen); err != nil {
    return err
  }
  s.ClientName = string(buf.Next(int(ClientNameLen)))
  if len(s.ClientName) != int(ClientNameLen) {
    return errors.New("string byte mismatch")
  }
  var AppIdLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &AppIdLen); err != nil {
    return err
  }
  s.AppId = string(buf.Next(int(AppIdLen)))
  if len(s.AppId) != int(AppIdLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (s *SecondaryAuthRequest) Pack(buf *bytes.Buffer) error {
  if len(s.SessionToken) > 255 {
    return errors.New("max_length overflow in field SessionToken")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(s.SessionToken))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.SessionToken); err != nil {
    return err
  }
  if len(s.ClientName) > 255 {
    return errors.New("max_length overflow in field ClientName")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(s.ClientName))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.ClientName); err != nil {
    return err
  }
  if len(s.AppId) > 255 {
    return errors.New("max_length overflow in field AppId")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(s.AppId))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.AppId); err != nil {
    return err
  }
  return nil
}

func (s *SecondaryAuthRequest) String() string {
  return fmt.Sprint("SessionToken: {", s.SessionToken, "} ",
    "ClientName: {", s.ClientName, "} ",
    "AppId: {", s.AppId, "}")
}


// STRUCTURE JwtRequest
type JwtRequest struct {
  ForceRefresh bool
}

func (j *JwtRequest) Size() uint32 {
  var result uint32
  result += 1 // ForceRefresh bool
  return result
}

func (j *JwtRequest) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &j.ForceRefresh); err != nil {
    return err
  }
  return nil
}

func (j *JwtRequest) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, j.ForceRefresh); err != nil {
    return err
  }
  return nil
}

func (j *JwtRequest) String() string {
  return fmt.Sprint("ForceRefresh: {", j.ForceRefresh, "}")
}


// STRUCTURE JwtResponse
type JwtResponse struct {
  JwtToken string
  Error TokenError
}

func (j *JwtResponse) Size() uint32 {
  var result uint32
  result += 2 // JwtToken length (uint_16)
  result += uint32(len(j.JwtToken)) // uint_8 array
  result += 1 // Error TokenError
  return result
}

func (j *JwtResponse) Unpack(buf *bytes.Buffer) error {
  var JwtTokenLen uint16
  if err := binary.Read(buf, binary.LittleEndian, &JwtTokenLen); err != nil {
    return err
  }
  j.JwtToken = string(buf.Next(int(JwtTokenLen)))
  if len(j.JwtToken) != int(JwtTokenLen) {
    return errors.New("string byte mismatch")
  }
  if err := binary.Read(buf, binary.LittleEndian, &j.Error); err != nil {
    return err
  }
  return nil
}

func (j *JwtResponse) Pack(buf *bytes.Buffer) error {
  if len(j.JwtToken) > 65535 {
    return errors.New("max_length overflow in field JwtToken")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint16(len(j.JwtToken))); err != nil {
    return err
  }
  if _, err := buf.WriteString(j.JwtToken); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, j.Error); err != nil {
    return err
  }
  return nil
}

func (j *JwtResponse) String() string {
  return fmt.Sprint("JwtToken: {", j.JwtToken, "} ",
    "Error: {", j.Error, "}")
}


// UNION TokenRequest
type TokenRequestTag uint8

const (
  TokenRequestTag_Auth        TokenRequestTag = iota // 0
  TokenRequestTag_Secondary                          // 1
  TokenRequestTag_Reassociate                        // 2
  TokenRequestTag_Jwt                                // 3
  TokenRequestTag_INVALID     TokenRequestTag = 255
)

type TokenRequest struct {
  tag *TokenRequestTag
  value clad.Struct
}

func (m *TokenRequest) Tag() TokenRequestTag {
  if m.tag == nil {
    return TokenRequestTag_INVALID
  }
  return *m.tag
}

func (m *TokenRequest) Size() uint32 {
  if m.tag == nil || *m.tag == TokenRequestTag_INVALID {
    return 1
  }
  return 1 + m.value.Size()
}

func (m *TokenRequest) Pack(buf *bytes.Buffer) error {
  tag := TokenRequestTag_INVALID
  if m.tag != nil {
    tag = *m.tag
  }
  if err := binary.Write(buf, binary.LittleEndian, tag); err != nil {
    return err
  }
  if tag == TokenRequestTag_INVALID {
    return nil
  }
  return m.value.Pack(buf)
}

func (m *TokenRequest) unpackStruct(tag TokenRequestTag, buf *bytes.Buffer) (clad.Struct, error) {
  switch tag {
  case TokenRequestTag_Auth:
    var ret AuthRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case TokenRequestTag_Secondary:
    var ret SecondaryAuthRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case TokenRequestTag_Reassociate:
    var ret ReassociateRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case TokenRequestTag_Jwt:
    var ret JwtRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  default:
    return nil, errors.New("invalid tag to unpackStruct")
  }
}

func (m *TokenRequest) Unpack(buf *bytes.Buffer) error {
  tag := TokenRequestTag_INVALID
  if err := binary.Read(buf, binary.LittleEndian, &tag); err != nil {
    return err
  }
  m.tag = &tag
  if tag == TokenRequestTag_INVALID {
    m.value = nil
    return nil
  }
  val, err := m.unpackStruct(tag, buf)
  if err != nil {
    *m.tag = TokenRequestTag_INVALID
    return err
  }
  m.value = val
  return nil
}

func (t TokenRequestTag) String() string {
  switch t {
  case TokenRequestTag_Auth:
    return "Auth"
  case TokenRequestTag_Secondary:
    return "Secondary"
  case TokenRequestTag_Reassociate:
    return "Reassociate"
  case TokenRequestTag_Jwt:
    return "Jwt"
  default:
    return "INVALID"
  }
}

func (m *TokenRequest) String() string {
  if m.tag == nil {
    return "nil"
  }
  if *m.tag == TokenRequestTag_INVALID {
    return "INVALID"
  }
  return fmt.Sprintf("%s: {%s}", *m.tag, m.value)
}

func (m *TokenRequest) GetAuth() *AuthRequest {
  if m.tag == nil || *m.tag != TokenRequestTag_Auth {
    return nil
  }
  return m.value.(*AuthRequest)
}

func (m *TokenRequest) SetAuth(value *AuthRequest) {
  newTag := TokenRequestTag_Auth
  m.tag = &newTag
  m.value = value
}

func NewTokenRequestWithAuth(value *AuthRequest) *TokenRequest {
  var ret TokenRequest
  ret.SetAuth(value)
  return &ret
}

func (m *TokenRequest) GetSecondary() *SecondaryAuthRequest {
  if m.tag == nil || *m.tag != TokenRequestTag_Secondary {
    return nil
  }
  return m.value.(*SecondaryAuthRequest)
}

func (m *TokenRequest) SetSecondary(value *SecondaryAuthRequest) {
  newTag := TokenRequestTag_Secondary
  m.tag = &newTag
  m.value = value
}

func NewTokenRequestWithSecondary(value *SecondaryAuthRequest) *TokenRequest {
  var ret TokenRequest
  ret.SetSecondary(value)
  return &ret
}

func (m *TokenRequest) GetReassociate() *ReassociateRequest {
  if m.tag == nil || *m.tag != TokenRequestTag_Reassociate {
    return nil
  }
  return m.value.(*ReassociateRequest)
}

func (m *TokenRequest) SetReassociate(value *ReassociateRequest) {
  newTag := TokenRequestTag_Reassociate
  m.tag = &newTag
  m.value = value
}

func NewTokenRequestWithReassociate(value *ReassociateRequest) *TokenRequest {
  var ret TokenRequest
  ret.SetReassociate(value)
  return &ret
}

func (m *TokenRequest) GetJwt() *JwtRequest {
  if m.tag == nil || *m.tag != TokenRequestTag_Jwt {
    return nil
  }
  return m.value.(*JwtRequest)
}

func (m *TokenRequest) SetJwt(value *JwtRequest) {
  newTag := TokenRequestTag_Jwt
  m.tag = &newTag
  m.value = value
}

func NewTokenRequestWithJwt(value *JwtRequest) *TokenRequest {
  var ret TokenRequest
  ret.SetJwt(value)
  return &ret
}


// UNION TokenResponse
type TokenResponseTag uint8

const (
  TokenResponseTag_Auth    TokenResponseTag = iota // 0
  TokenResponseTag_Jwt                             // 1
  TokenResponseTag_INVALID TokenResponseTag = 255
)

type TokenResponse struct {
  tag *TokenResponseTag
  value clad.Struct
}

func (m *TokenResponse) Tag() TokenResponseTag {
  if m.tag == nil {
    return TokenResponseTag_INVALID
  }
  return *m.tag
}

func (m *TokenResponse) Size() uint32 {
  if m.tag == nil || *m.tag == TokenResponseTag_INVALID {
    return 1
  }
  return 1 + m.value.Size()
}

func (m *TokenResponse) Pack(buf *bytes.Buffer) error {
  tag := TokenResponseTag_INVALID
  if m.tag != nil {
    tag = *m.tag
  }
  if err := binary.Write(buf, binary.LittleEndian, tag); err != nil {
    return err
  }
  if tag == TokenResponseTag_INVALID {
    return nil
  }
  return m.value.Pack(buf)
}

func (m *TokenResponse) unpackStruct(tag TokenResponseTag, buf *bytes.Buffer) (clad.Struct, error) {
  switch tag {
  case TokenResponseTag_Auth:
    var ret AuthResponse
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case TokenResponseTag_Jwt:
    var ret JwtResponse
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  default:
    return nil, errors.New("invalid tag to unpackStruct")
  }
}

func (m *TokenResponse) Unpack(buf *bytes.Buffer) error {
  tag := TokenResponseTag_INVALID
  if err := binary.Read(buf, binary.LittleEndian, &tag); err != nil {
    return err
  }
  m.tag = &tag
  if tag == TokenResponseTag_INVALID {
    m.value = nil
    return nil
  }
  val, err := m.unpackStruct(tag, buf)
  if err != nil {
    *m.tag = TokenResponseTag_INVALID
    return err
  }
  m.value = val
  return nil
}

func (t TokenResponseTag) String() string {
  switch t {
  case TokenResponseTag_Auth:
    return "Auth"
  case TokenResponseTag_Jwt:
    return "Jwt"
  default:
    return "INVALID"
  }
}

func (m *TokenResponse) String() string {
  if m.tag == nil {
    return "nil"
  }
  if *m.tag == TokenResponseTag_INVALID {
    return "INVALID"
  }
  return fmt.Sprintf("%s: {%s}", *m.tag, m.value)
}

func (m *TokenResponse) GetAuth() *AuthResponse {
  if m.tag == nil || *m.tag != TokenResponseTag_Auth {
    return nil
  }
  return m.value.(*AuthResponse)
}

func (m *TokenResponse) SetAuth(value *AuthResponse) {
  newTag := TokenResponseTag_Auth
  m.tag = &newTag
  m.value = value
}

func NewTokenResponseWithAuth(value *AuthResponse) *TokenResponse {
  var ret TokenResponse
  ret.SetAuth(value)
  return &ret
}

func (m *TokenResponse) GetJwt() *JwtResponse {
  if m.tag == nil || *m.tag != TokenResponseTag_Jwt {
    return nil
  }
  return m.value.(*JwtResponse)
}

func (m *TokenResponse) SetJwt(value *JwtResponse) {
  newTag := TokenResponseTag_Jwt
  m.tag = &newTag
  m.value = value
}

func NewTokenResponseWithJwt(value *JwtResponse) *TokenResponse {
  var ret TokenResponse
  ret.SetJwt(value)
  return &ret
}