package notify

import (
	"errors"
	"fmt"
	"reflect"
)

func (m MsgVal) ToClearString() string {
	return string(m)
}

func (m MsgVal) ToInterface() (interface{}, error) {
	return Decode(m)
}

func (m MsgVal) MustToInterface() interface{} {
	inf, err := m.ToInterface()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToString() (string, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return "", err
	}
	if data, ok := inf.(string); !ok {
		return "", errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToString() string {
	inf, err := m.ToString()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToInt32() (int32, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return 0, err
	}
	if data, ok := inf.(int32); !ok {
		return 0, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToInt32() int32 {
	inf, err := m.ToInt32()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToInt() (int, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return 0, err
	}
	if data, ok := inf.(int); !ok {
		return 0, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToInt() int {
	inf, err := m.ToInt()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToUint64() (uint64, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return 0, err
	}
	if data, ok := inf.(uint64); !ok {
		return 0, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToUint64() uint64 {
	inf, err := m.ToUint64()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToUint32() (uint32, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return 0, err
	}
	if data, ok := inf.(uint32); !ok {
		return 0, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToUint32() uint32 {
	inf, err := m.ToUint32()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToUint() (uint, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return 0, err
	}
	if data, ok := inf.(uint); !ok {
		return 0, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToUint() uint {
	inf, err := m.ToUint()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToBool() (bool, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return false, err
	}
	if data, ok := inf.(bool); !ok {
		return false, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToBool() bool {
	inf, err := m.ToBool()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToFloat64() (float64, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return 0, err
	}
	if data, ok := inf.(float64); !ok {
		return 0, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToFloat64() float64 {
	inf, err := m.ToFloat64()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToFloat32() (float32, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return 0, err
	}
	if data, ok := inf.(float32); !ok {
		return 0, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToFloat32() float32 {
	inf, err := m.ToFloat32()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToSliceString() ([]string, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return []string{}, err
	}
	if data, ok := inf.([]string); !ok {
		return []string{}, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToSliceString() []string {
	inf, err := m.ToSliceString()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToSliceInt64() ([]int64, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return []int64{}, err
	}
	if data, ok := inf.([]int64); !ok {
		return []int64{}, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToSliceInt64() []int64 {
	inf, err := m.ToSliceInt64()
	if err != nil {
		panic(err)
	}
	return inf
}

func (m MsgVal) ToSliceFloat64() ([]float64, error) {
	inf, err := m.ToInterface()
	if err != nil {
		return []float64{}, err
	}
	if data, ok := inf.([]float64); !ok {
		return []float64{}, errors.New("source data not match target type")
	} else {
		return data, nil
	}
}

func (m MsgVal) MustToSliceFloat64() []float64 {
	inf, err := m.ToSliceFloat64()
	if err != nil {
		panic(err)
	}
	return inf
}

func ToMsgVal(val interface{}) (MsgVal, error) {
	return Encode(val)
}

func MustToMsgVal(val interface{}) MsgVal {
	d, err := ToMsgVal(val)
	if err != nil {
		panic(err)
	}
	return d
}

func (m MsgVal) Orm(stu interface{}) error {
	inf, err := m.ToInterface()
	if err != nil {
		return err
	}
	t := reflect.TypeOf(stu)
	if t.Kind() != reflect.Ptr {
		return errors.New("interface not writable(pointer wanted)")
	}
	if !reflect.ValueOf(stu).Elem().CanSet() {
		return errors.New("interface not writable")
	}
	it := reflect.TypeOf(inf)
	if t.Elem().Kind() != it.Kind() {
		return fmt.Errorf("interface{} kind is %v,not %v", t.Elem().Kind(), it.Kind())
	}
	if t.Elem().Name() != it.Name() {
		return fmt.Errorf("interface{} name is %v,not %v", t.Elem().Name(), it.Name())
	}
	if t.Elem().String() != it.String() {
		return fmt.Errorf("interface{} string is %v,not %v", t.Elem().String(), it.String())
	}
	reflect.ValueOf(stu).Elem().Set(reflect.ValueOf(inf))
	return nil
}