package server

import (
	"io"
	"sync"
	"time"
)

type ServerStats struct {
	// The number of request performed.
	RequestCount uint64

	// The total aggregate time for all request in milliseconds.
	//
	// This time can be used for calculating the average response time
	// per request:
	//     avgRequesttime = RequestTime / RequestCount
	RequestTime uint64

	// The number of bytes written to the underlying connections.
	BytesWritten uint64

	// The number of bytes read from the underlying connections.
	BytesRead uint64

	// The number of Read() calls.
	ReadCalls uint64

	// The number of Read() errors.
	ReadErrors uint64

	// The number of Write() calls.
	WriteCalls uint64

	// The number of Write() errors.
	WriteErrors uint64

	// The number of Dial() calls.
	DialCalls uint64

	// The number of Dial() errors.
	DialErrors uint64

	// The number of Accept() calls.
	AcceptCalls uint64

	// The number of Accept() errors.
	AcceptErrors uint64

	// lock is for 386 builds. See https://github.com/valyala/gorpc/issues/5 .
	lock sync.Mutex
}

// AvgRequestTime returns the average Request execution time.
//
// Use stats returned from ServerStats.Snapshot() on live Client and / or Server,
// since the original stats can be updated by concurrently running goroutines.
func (ss *ServerStats) AvgRequestTime() time.Duration {
	return time.Duration(float64(ss.RequestTime)/float64(ss.RequestCount)) * time.Millisecond
}

// AvgRequestBytes returns the average bytes sent / received per Request.
//
// Use stats returned from ServerStats.Snapshot() on live Client and / or Server,
// since the original stats can be updated by concurrently running goroutines.
func (ss *ServerStats) AvgRequestBytes() (send float64, recv float64) {
	return float64(ss.BytesWritten) / float64(ss.RequestCount), float64(ss.BytesRead) / float64(ss.RequestCount)
}

// AvgRequestCalls returns the average number of write() / read() syscalls per Request.
//
// Use stats returned from ServerStats.Snapshot() on live Client and / or Server,
// since the original stats can be updated by concurrently running goroutines.
func (ss *ServerStats) AvgRequestCalls() (write float64, read float64) {
	return float64(ss.WriteCalls) / float64(ss.RequestCount), float64(ss.ReadCalls) / float64(ss.RequestCount)
}

type writerCounter struct {
	w  io.Writer
	ss *ServerStats
}

type readerCounter struct {
	r  io.Reader
	ss *ServerStats
}

func newWriterCounter(w io.Writer, ss *ServerStats) io.Writer {
	return &writerCounter{
		w:  w,
		ss: ss,
	}
}

func newReaderCounter(r io.Reader, ss *ServerStats) io.Reader {
	return &readerCounter{
		r:  r,
		ss: ss,
	}
}

func (w *writerCounter) Write(p []byte) (int, error) {
	n, err := w.w.Write(p)
	w.ss.incWriteCalls()
	if err != nil {
		w.ss.incWriteErrors()
	}
	w.ss.addBytesWritten(uint64(n))
	return n, err
}

func (r *readerCounter) Read(p []byte) (int, error) {
	n, err := r.r.Read(p)
	r.ss.incReadCalls()
	if err != nil {
		r.ss.incReadErrors()
	}
	r.ss.addBytesRead(uint64(n))
	return n, err
}