sim

type Counter struct {
	Cur Matrix
	Sum Matrix
}

type Display interface {
	Start(setup *Setup)

	TakesHour() bool
	DrawHour(r *HourReport)

	Stop()
}

type Estimator interface {
	// Returns the demand for the next weeklen
	Estimate() (structs.Matrix, uint64)
}

type Events uint64

type Flows interface {
	Nflow() int
}

type Hosts interface {
	// Called every tick, may send packets to the sender,
	// which will be relayed to the switch.
	Tick(sender blocks.Sender)

	// Hosts are blocks. They receive packets from the switch.
	blocks.Block
}

type HourReport struct {
	T        uint64
	NewWeek  bool
	Send     Matrix
	Recv     Matrix
	CircRecv Matrix
	PackRecv Matrix
	Drop     Matrix
	Sched    Matrix
}

type LineProgress struct {
	NoSingleLine bool

	Flows Flows
	// contains filtered or unexported fields
}

type Monitor interface {
	// Tells the demand for the current tick.
	Tell(demand structs.Matrix)
}

type Progress interface {
	Start(s *ProgressStat)
	Tick(s *ProgressStat)
	Stop(s *ProgressStat)
}

type ProgressStat struct {
	T        uint64 // time now
	Goodput  uint64 // Bytes delivered
	Circput  uint64 // Bytes delivered via circuit
	Packput  uint64 // Bytes delivered via packet
	Dropped  uint64 // Bytes dropped
	Capacity uint64 // Bytes could deliver
}

type Recorder struct {
	// contains filtered or unexported fields
}

type SchedRecorder struct {
	// contains filtered or unexported fields
}

type Scheduler interface {
	// Based on the "demand" given for the next "wind" amount of ticks
	// Returns a series of days, and the allocated bandwidth matrix
	Schedule(leftover, demand Matrix, wind uint64) (days []*Day, bandw Matrix)
}

type Setup struct {
	Nhost     int
	LinkBw    uint64
	PackBw    uint64
	WeekLen   uint64
	MinDayLen uint64
	AvgDayLen uint64
	NightLen  uint64

	NicBufSize    uint64
	SwitchBufSize uint64

	TickPerHour uint64

	TickTime time.Duration
}

type Stopper interface {
	ShouldStop() bool
}

type Switch interface {
	// Tells if the switch is a TDMA switch.
	Tdma() bool

	/*
		A switch is a sender where other parts can
		queue some packet onto the switch.
		Nics queues are also part of the switch.
	*/
	blocks.Sender

	/*
		Moves packet inside the switch to the sink.

		If the switch is a TDMA switch (a circuit switch or a
		hybrid switches), it uses the estimator to estimate
		the demand in the near future. Returns the schedule for
		current tick, and the schedule events that happens at
		the end of the tick.

		If the switch is not a TDMA switch (a packet switch),
		then it just moves packets, and always returns (nil, 0)
	*/
	Tick(sink blocks.Block, estimator Estimator) (Matrix, Events)

	// Sets the switch to use a particular scheduler
	Bind(s Scheduler, logger *SchedRecorder)

	Served() (circ Matrix, pack Matrix)
}

type Testbed struct {
	Hosts     Hosts     // Send and receive packets
	Switch    Switch    // Transmits packets from host to host
	Estimator Estimator // (TDMA switch only), estimates the upcoming demands
	Scheduler Scheduler // (TDMA switch only), breaks the demand into days
	Monitor   Monitor   // (optional) tracks past demands
	Stopper   Stopper   // (optional) tells the testbed to stop
	Display   Display   // (optional) displays the simulation status
	Progress  Progress  // (optional) shows the simulation progress

	WarmUp  uint64
	EndTime uint64 // The time that the simulation ends

	*ProgressStat
	// contains filtered or unexported fields
}

type Tick struct {
	T uint64

	NewWeek bool
	Dusk    bool
	Dawn    bool

	Send  Matrix
	Recv  Matrix
	Circ  Matrix
	Pack  Matrix
	Drop  Matrix
	Sched Matrix
}