cmd

var RootCmd = &cmds.Command{
	Helptext: cmds.HelpText{
		Tagline: "Filecoin decentralized storage network client",
		Subcommands: `
START RUNNING VENUS
  daemon                 - Start a venus daemon process
  wallet                 - Manage wallet
  info                   - Print node info

VIEW DATA STRUCTURES
  chain                  - Inspect the filecoin blockchain
  sync                   - Inspect the filecoin Sync

NETWORK COMMANDS
  swarm                  - Interact with the swarm
  drand                  - Retrieve randomness from drand server

MESSAGE COMMANDS
  send                   - Send message
  mpool                  - Manage the message pool

MINER COMMANDS
  miner                  - Interact with actors

State COMMANDS
  state                  - query states of the filecoin network

Paych COMMANDS 
  paych                  - Manage payment channels

Cid COMMANDS
  manifest-cid-from-car  - Get the manifest CID from a car file

Evm COMMANDS
  evm                    - Commands related to the Filecoin EVM runtime

TOOL COMMANDS
  inspect                - Show info about the venus node
  log                    - Interact with the daemon event log output
  version                - Show venus version information
  seed                   - Seal sectors for genesis miner
  fetch                  - Fetch proving parameters
`,
	},
	Options: []cmds.Option{
		cmds.StringsOption(OptionToken, "set the auth token to use"),
		cmds.StringOption(OptionAPI, "set the api port to use"),
		cmds.StringOption(OptionRepoDir, OptionLegacyRepoDir, "set the repo directory, defaults to ~/.venus"),
		cmds.StringOption(cmds.EncLong, cmds.EncShort, "The encoding type the output should be encoded with (pretty-json or json)").WithDefault("pretty-json"),
		cmds.BoolOption("help", "Show the full command help text."),
		cmds.BoolOption("h", "Show a short version of the command help text."),
	},
	Subcommands: make(map[string]*cmds.Command),
}

var RootCmdDaemon = &cmds.Command{
	Subcommands: make(map[string]*cmds.Command),
}

var StateComputeStateCmd = &cmds.Command{
	Helptext: cmds.HelpText{
		Tagline: "Perform state computations",
	},
	Options: []cmds.Option{
		cmds.Uint64Option("vm-height", "set the height that the vm will see"),
		cmds.BoolOption("apply-mpool-messages", "apply messages from the mempool to the computed state"),
		cmds.BoolOption("show-trace", "print out full execution trace for given tipset"),
		cmds.BoolOption("json", "generate json output"),
		cmds.StringOption("compute-state-output", "a json file containing pre-existing compute-state output, to generate html reports without rerunning state changes"),
		cmds.BoolOption("no-timing", "don't show timing information in html traces"),
		cmds.StringOption("tipset", ""),
	},
	Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) error {
		ctx := req.Context

		h, _ := req.Options["vm-height"].(uint64)
		height := abi.ChainEpoch(h)
		var ts *types.TipSet
		var err error
		chainAPI := getEnv(env).ChainAPI
		if tss := req.Options["tipset"].(string); tss != "" {
			ts, err = ParseTipSetRef(ctx, chainAPI, tss)
		} else if height > 0 {
			ts, err = chainAPI.ChainGetTipSetByHeight(ctx, height, types.EmptyTSK)
		} else {
			ts, err = chainAPI.ChainHead(ctx)
		}
		if err != nil {
			return err
		}

		if height == 0 {
			height = ts.Height()
		}

		var msgs []*types.Message
		if applyMsg, _ := req.Options["apply-mpool-messages"].(bool); applyMsg {
			pmsgs, err := getEnv(env).MessagePoolAPI.MpoolSelect(ctx, ts.Key(), 1)
			if err != nil {
				return err
			}

			for _, sm := range pmsgs {
				msgs = append(msgs, &sm.Message)
			}
		}

		var stout *types.ComputeStateOutput
		if csofile, _ := req.Options["compute-state-output"].(string); len(csofile) != 0 {
			data, err := os.ReadFile(csofile)
			if err != nil {
				return err
			}

			var o types.ComputeStateOutput
			if err := json.Unmarshal(data, &o); err != nil {
				return err
			}

			stout = &o
		} else {
			o, err := getEnv(env).ChainAPI.StateCompute(ctx, height, msgs, ts.Key())
			if err != nil {
				return err
			}

			stout = o
		}

		buf := &bytes.Buffer{}
		writer := NewSilentWriter(buf)

		if ok, _ := req.Options["json"].(bool); ok {
			out, err := json.Marshal(stout)
			if err != nil {
				return err
			}
			writer.Println(string(out))
			return re.Emit(buf)
		}

		writer.Println("computed state cid: ", stout.Root)
		if showTrace, _ := req.Options["show-trace"].(bool); showTrace {
			for _, ir := range stout.Trace {
				writer.Printf("%s\t%s\t%s\t%d\t%x\t%d\t%x\n", ir.Msg.From, ir.Msg.To, ir.Msg.Value, ir.Msg.Method, ir.Msg.Params, ir.MsgRct.ExitCode, ir.MsgRct.Return)
				printInternalExecutions(writer, "\t", ir.ExecutionTrace.Subcalls)
			}
		}

		return re.Emit(buf)
	},
}