var ErrDataEncoding = errors.New("unkown data field encoding")

var ObjectCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Interact with IPFS objects.",
        ShortDescription: `
'ipfs object' is a plumbing command used to manipulate DAG objects
directly.`,
    },

    Subcommands: map[string]*cmds.Command{
        "data":  ObjectDataCmd,
        "diff":  ObjectDiffCmd,
        "get":   ObjectGetCmd,
        "links": ObjectLinksCmd,
        "new":   ObjectNewCmd,
        "patch": ObjectPatchCmd,
        "put":   ObjectPutCmd,
        "stat":  ObjectStatCmd,
    },
}

var ObjectDataCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Output the raw bytes of an IPFS object.",
        ShortDescription: "" /* 158 byte string literal not displayed */,

        LongDescription: "" /* 269 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("key", true, false, "Key of the object to retrieve, in base58-encoded multihash format.").EnableStdin(),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        path := path.New(req.Arguments[0])

        data, err := api.Object().Data(req.Context, path)
        if err != nil {
            return err
        }

        return res.Emit(data)
    },
}

var ObjectDiffCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Display the diff between two ipfs objects.",
        ShortDescription: `
'ipfs object diff' is a command used to show the differences between
two IPFS objects.`,
        LongDescription: "" /* 624 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("obj_a", true, false, "Object to diff against."),
        cmds.StringArg("obj_b", true, false, "Object to diff."),
    },
    Options: []cmds.Option{
        cmds.BoolOption(verboseOptionName, "v", "Print extra information."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        pa := path.New(req.Arguments[0])
        pb := path.New(req.Arguments[1])

        changes, err := api.Object().Diff(req.Context, pa, pb)
        if err != nil {
            return err
        }

        out := make([]*dagutils.Change, len(changes))
        for i, change := range changes {
            out[i] = &dagutils.Change{
                Type: change.Type,
                Path: change.Path,
            }

            if change.Before != nil {
                out[i].Before = change.Before.Cid()
            }

            if change.After != nil {
                out[i].After = change.After.Cid()
            }
        }

        return cmds.EmitOnce(res, &Changes{out})
    },
    Type: Changes{},
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Changes) error {
            verbose, _ := req.Options[verboseOptionName].(bool)

            for _, change := range out.Changes {
                if verbose {
                    switch change.Type {
                    case dagutils.Add:
                        fmt.Fprintf(w, "Added new link %q pointing to %s.\n", change.Path, change.After)
                    case dagutils.Mod:
                        fmt.Fprintf(w, "Changed %q from %s to %s.\n", change.Path, change.Before, change.After)
                    case dagutils.Remove:
                        fmt.Fprintf(w, "Removed link %q (was %s).\n", change.Path, change.Before)
                    }
                } else {
                    switch change.Type {
                    case dagutils.Add:
                        fmt.Fprintf(w, "+ %s %q\n", change.After, change.Path)
                    case dagutils.Mod:
                        fmt.Fprintf(w, "~ %s %s %q\n", change.Before, change.After, change.Path)
                    case dagutils.Remove:
                        fmt.Fprintf(w, "- %s %q\n", change.Before, change.Path)
                    }
                }
            }

            return nil
        }),
    },
}

var ObjectGetCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Get and serialize the DAG node named by <key>.",
        ShortDescription: "" /* 209 byte string literal not displayed */,

        LongDescription: "" /* 494 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("key", true, false, "Key of the object to retrieve, in base58-encoded multihash format.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.StringOption(encodingOptionName, "Encoding type of the data field, either \"text\" or \"base64\".").WithDefault("text"),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        enc, err := cmdenv.GetLowLevelCidEncoder(req)
        if err != nil {
            return err
        }

        path := path.New(req.Arguments[0])

        datafieldenc, _ := req.Options[encodingOptionName].(string)
        if err != nil {
            return err
        }

        nd, err := api.Object().Get(req.Context, path)
        if err != nil {
            return err
        }

        r, err := api.Object().Data(req.Context, path)
        if err != nil {
            return err
        }

        data, err := ioutil.ReadAll(r)
        if err != nil {
            return err
        }

        out, err := encodeData(data, datafieldenc)
        if err != nil {
            return err
        }

        node := &Node{
            Links: make([]Link, len(nd.Links())),
            Data:  out,
        }

        for i, link := range nd.Links() {
            node.Links[i] = Link{
                Hash: enc.Encode(link.Cid),
                Name: link.Name,
                Size: link.Size,
            }
        }

        return cmds.EmitOnce(res, node)
    },
    Type: Node{},
    Encoders: cmds.EncoderMap{
        cmds.Protobuf: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Node) error {

            object, err := deserializeNode(out, "text")
            if err != nil {
                return nil
            }

            marshaled, err := object.Marshal()
            if err != nil {
                return err
            }
            _, err = w.Write(marshaled)
            return err
        }),
    },
}

var ObjectLinksCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Output the links pointed to by the specified object.",
        ShortDescription: "" /* 150 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("key", true, false, "Key of the object to retrieve, in base58-encoded multihash format.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.BoolOption(headersOptionName, "v", "Print table headers (Hash, Size, Name)."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        enc, err := cmdenv.GetLowLevelCidEncoder(req)
        if err != nil {
            return err
        }

        path := path.New(req.Arguments[0])

        rp, err := api.ResolvePath(req.Context, path)
        if err != nil {
            return err
        }

        links, err := api.Object().Links(req.Context, rp)
        if err != nil {
            return err
        }

        outLinks := make([]Link, len(links))
        for i, link := range links {
            outLinks[i] = Link{
                Hash: enc.Encode(link.Cid),
                Name: link.Name,
                Size: link.Size,
            }
        }

        out := &Object{
            Hash:  enc.Encode(rp.Cid()),
            Links: outLinks,
        }

        return cmds.EmitOnce(res, out)
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Object) error {
            tw := tabwriter.NewWriter(w, 1, 2, 1, ' ', 0)
            headers, _ := req.Options[headersOptionName].(bool)
            if headers {
                fmt.Fprintln(tw, "Hash\tSize\tName")
            }
            for _, link := range out.Links {
                fmt.Fprintf(tw, "%s\t%v\t%s\n", link.Hash, link.Size, link.Name)
            }
            tw.Flush()

            return nil
        }),
    },
    Type: &Object{},
}

var ObjectNewCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Create a new object from an ipfs template.",
        ShortDescription: `
'ipfs object new' is a plumbing command for creating new DAG nodes.
`,
        LongDescription: "" /* 247 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("template", false, false, "Template to use. Optional."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        enc, err := cmdenv.GetLowLevelCidEncoder(req)
        if err != nil {
            return err
        }

        template := "empty"
        if len(req.Arguments) == 1 {
            template = req.Arguments[0]
        }

        nd, err := api.Object().New(req.Context, options.Object.Type(template))
        if err != nil && err != io.EOF {
            return err
        }

        return cmds.EmitOnce(res, &Object{Hash: enc.Encode(nd.Cid())})
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Object) error {
            fmt.Fprintln(w, out.Hash)
            return nil
        }),
    },
    Type: Object{},
}

var ObjectPatchCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Create a new merkledag object based on an existing one.",
        ShortDescription: "" /* 208 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{},
    Subcommands: map[string]*cmds.Command{
        "append-data": patchAppendDataCmd,
        "add-link":    patchAddLinkCmd,
        "rm-link":     patchRmLinkCmd,
        "set-data":    patchSetDataCmd,
    },
}

var ObjectPutCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Store input as a DAG object, print its key.",
        ShortDescription: "" /* 133 byte string literal not displayed */,

        LongDescription: "" /* 704 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.FileArg("data", true, false, "Data to be stored as a DAG object.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.StringOption(inputencOptionName, "Encoding type of input data. One of: {\"protobuf\", \"json\"}.").WithDefault("json"),
        cmds.StringOption(datafieldencOptionName, "Encoding type of the data field, either \"text\" or \"base64\".").WithDefault("text"),
        cmds.BoolOption(pinOptionName, "Pin this object when adding."),
        cmds.BoolOption(quietOptionName, "q", "Write minimal output."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        enc, err := cmdenv.GetLowLevelCidEncoder(req)
        if err != nil {
            return err
        }

        file, err := cmdenv.GetFileArg(req.Files.Entries())
        if err != nil {
            return err
        }

        inputenc, _ := req.Options[inputencOptionName].(string)
        if err != nil {
            return err
        }

        datafieldenc, _ := req.Options[datafieldencOptionName].(string)
        if err != nil {
            return err
        }

        dopin, _ := req.Options[pinOptionName].(bool)
        if err != nil {
            return err
        }

        p, err := api.Object().Put(req.Context, file,
            options.Object.DataType(datafieldenc),
            options.Object.InputEnc(inputenc),
            options.Object.Pin(dopin))
        if err != nil {
            return err
        }

        return cmds.EmitOnce(res, &Object{Hash: enc.Encode(p.Cid())})
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Object) error {
            quiet, _ := req.Options[quietOptionName].(bool)

            o := out.Hash
            if !quiet {
                o = "added " + o
            }

            fmt.Fprintln(w, o)

            return nil
        }),
    },
    Type: Object{},
}

var ObjectStatCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Get stats for the DAG node named by <key>.",
        ShortDescription: "" /* 395 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("key", true, false, "Key of the object to retrieve, in base58-encoded multihash format.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.BoolOption(humanOptionName, "Print sizes in human readable format (e.g., 1K 234M 2G)"),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        enc, err := cmdenv.GetLowLevelCidEncoder(req)
        if err != nil {
            return err
        }

        ns, err := api.Object().Stat(req.Context, path.New(req.Arguments[0]))
        if err != nil {
            return err
        }

        oldStat := &ipld.NodeStat{
            Hash:           enc.Encode(ns.Cid),
            NumLinks:       ns.NumLinks,
            BlockSize:      ns.BlockSize,
            LinksSize:      ns.LinksSize,
            DataSize:       ns.DataSize,
            CumulativeSize: ns.CumulativeSize,
        }

        return cmds.EmitOnce(res, oldStat)
    },
    Type: ipld.NodeStat{},
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *ipld.NodeStat) error {
            wtr := tabwriter.NewWriter(w, 0, 0, 1, ' ', 0)
            defer wtr.Flush()
            fw := func(s string, n int) {
                fmt.Fprintf(wtr, "%s:\t%d\n", s, n)
            }
            human, _ := req.Options[humanOptionName].(bool)
            fw("NumLinks", out.NumLinks)
            fw("BlockSize", out.BlockSize)
            fw("LinksSize", out.LinksSize)
            fw("DataSize", out.DataSize)
            if human {
                fmt.Fprintf(wtr, "%s:\t%s\n", "CumulativeSize", humanize.Bytes(uint64(out.CumulativeSize)))
            } else {
                fw("CumulativeSize", out.CumulativeSize)
            }

            return nil
        }),
    },
}

type Changes struct {
    Changes []*dagutils.Change
}

type Link struct {
    Name, Hash string
    Size       uint64
}

type Node struct {
    Links []Link
    Data  string
}

type Object struct {
    Hash  string `json:"Hash,omitempty"`
    Links []Link `json:"Links,omitempty"`
}