package daemon
 
 import (
 	"encoding/json"

 	"io"
 

 	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/daemon/execdriver"

 	"github.com/docker/libnetwork/sandbox"

 	"github.com/opencontainers/runc/libcontainer"

 )
 

 type ContainerStatsConfig struct {
 	Stream    bool
 	OutStream io.Writer
 	Stop      <-chan bool
 }
 
 func (daemon *Daemon) ContainerStats(name string, config *ContainerStatsConfig) error {

 	updates, err := daemon.SubscribeToContainerStats(name)

 	if err != nil {

 		return err

 	}

 	if config.Stream {
 		config.OutStream.Write(nil)
 	}
 

 	var preCpuStats types.CpuStats
 	getStat := func(v interface{}) *types.Stats {

 		update := v.(*execdriver.ResourceStats)

 		// Retrieve the nw statistics from libnetwork and inject them in the Stats
 		if nwStats, err := daemon.getNetworkStats(name); err == nil {
 			update.Stats.Interfaces = nwStats
 		}

 		ss := convertStatsToAPITypes(update.Stats)
 		ss.PreCpuStats = preCpuStats

 		ss.MemoryStats.Limit = uint64(update.MemoryLimit)
 		ss.Read = update.Read
 		ss.CpuStats.SystemUsage = update.SystemUsage

 		preCpuStats = ss.CpuStats
 		return ss
 	}
 

 	enc := json.NewEncoder(config.OutStream)

 	defer daemon.UnsubscribeToContainerStats(name, updates)

 	noStreamFirstFrame := true
 	for {
 		select {
 		case v, ok := <-updates:
 			if !ok {
 				return nil
 			}
 
 			s := getStat(v)
 			if !config.Stream && noStreamFirstFrame {
 				// prime the cpu stats so they aren't 0 in the final output
 				noStreamFirstFrame = false
 				continue
 			}
 
 			if err := enc.Encode(s); err != nil {
 				return err
 			}

 			if !config.Stream {
 				return nil
 			}
 		case <-config.Stop:
 			return nil

 		}
 	}
 }

 
 func (daemon *Daemon) getNetworkStats(name string) ([]*libcontainer.NetworkInterface, error) {
 	var list []*libcontainer.NetworkInterface
 
 	c, err := daemon.Get(name)
 	if err != nil {
 		return list, err
 	}
 
 	nw, err := daemon.netController.NetworkByID(c.NetworkSettings.NetworkID)
 	if err != nil {
 		return list, err
 	}
 	ep, err := nw.EndpointByID(c.NetworkSettings.EndpointID)
 	if err != nil {
 		return list, err
 	}
 
 	stats, err := ep.Statistics()
 	if err != nil {
 		return list, err
 	}
 
 	// Convert libnetwork nw stats into libcontainer nw stats
 	for ifName, ifStats := range stats {
 		list = append(list, convertLnNetworkStats(ifName, ifStats))
 	}
 
 	return list, nil
 }
 
 func convertLnNetworkStats(name string, stats *sandbox.InterfaceStatistics) *libcontainer.NetworkInterface {
 	n := &libcontainer.NetworkInterface{Name: name}
 	n.RxBytes = stats.RxBytes
 	n.RxPackets = stats.RxPackets
 	n.RxErrors = stats.RxErrors
 	n.RxDropped = stats.RxDropped
 	n.TxBytes = stats.TxBytes
 	n.TxPackets = stats.TxPackets
 	n.TxErrors = stats.TxErrors
 	n.TxDropped = stats.TxDropped
 	return n
 }