package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("Testing Rat")

	rat1 := big.NewRat(10, 5)

	// The Rat works gob encode and decode
	rat1Bytes, err := Serialize(rat1)
	if err != nil {
		fmt.Printf("Error on serializing rat1: %v", err)
	}

	rat2 := &big.Rat{}
	err = Deserialize(rat1Bytes, rat2)
	if err != nil {
		fmt.Printf("Error on deserializing rat1: %v", err)
	}

	if rat2.String() == rat1.String() {
		fmt.Println("rat1 == rat2")
	}

	fmt.Println("Testing CustomRat")

	// CustomRat encode works and decode fails due nil object
	// Uncomment GobEncode and GobDecode to make encode and decode works
	customRat1 := &CustomRat{big.NewRat(10, 5)}

	customRat1Bytes, err := Serialize(customRat1)
	if err != nil {
		fmt.Printf("Error on serializing rat1: %v", err)
	}

	customRat2 := &CustomRat{}
	err = Deserialize(customRat1Bytes, customRat2)
	if err != nil {
		fmt.Printf("Error on deserializing rat1: %v", err)
	}

	if rat2.String() == rat1.String() {
		fmt.Println("customRat1 == customRat2")
	}
}

func Serialize(val interface{}) ([]byte, error) {
	b := new(bytes.Buffer)
	if err := gob.NewEncoder(b).Encode(val); err != nil {
		return nil, err
	}
	return b.Bytes(), nil
}

func Deserialize(data []byte, result interface{}) error {
	return gob.NewDecoder(bytes.NewBuffer(data)).Decode(result)
}

type CustomRat struct {
	*big.Rat
}

// Uncomment the below GobDecode and GobEncode for CustomRat to work.
//func (cr *CustomRat) GobDecode(data []byte) error {
//	cr.Rat = &big.Rat{}
//	return cr.Rat.GobDecode(data)
//}
//
//func (cr *CustomRat) GobEncode() ([]byte, error) {
//	return cr.Rat.GobEncode()
//}