package main

import (
	"encoding/json"
	"fmt"
)

type TraceEventGetStateCommand struct {
	Name string `json:"name"`
}

func (self *TraceEventGetStateCommand) MarshalJSON() ([]byte, error) {
	type Arguments TraceEventGetStateCommand
	return json.Marshal(&struct {
		Execute   string     `json:"execute"`
		Arguments *Arguments `json:"arguments"`
	}{
		Execute:   "trace-event-get-state",
		Arguments: (*Arguments)(self),
	})
}

type TraceEventInfo struct {
	Name  string `json:"name"`
	State string `json:"state"`
}

func (self *TraceEventInfo) UnmarshalJSON(data []byte) error {
	type Return TraceEventInfo
	ret := struct {
		Return Return `json:"return"`
	}{}
	err := json.Unmarshal(data, &ret)
	if err != nil {
		return err
	}
	self.Name = ret.Return.Name
	self.State = ret.Return.State
	return nil
}

func main() {
	var err error
	var qmp_input []byte
	var qmp_output []byte

	cmd := TraceEventGetStateCommand{
		Name: "qemu_memalign",
	}
	if qmp_input, err = json.Marshal(&cmd); err != nil {
		panic(err)
	}
	fmt.Printf("   cmd: %v\n", cmd)
	fmt.Printf("-> qmp_input: %v\n", string(qmp_input))

	qmp_output = ([]byte)(`{"return":{"name":"qemu_memalign","state":"disabled"}}`)
	ret := TraceEventInfo{}
	if err = json.Unmarshal(qmp_output, &ret); err != nil {
		panic(err)
	}
	fmt.Printf("<- qmp_output: %v\n", string(qmp_output))
	fmt.Printf("   ret: %v\n", ret)
}