package server

import (
	"crypto/tls"
	"net"
	"time"
)

type ConnectionHandler interface {
	GetConcurrency() int
	GetKeepAlive() time.Duration
	GetHandshakeTimeout() time.Duration
	GetTLSConfig() *tls.Config

	Listener(serverCtx ServerCtx) (net.Listener, error)
}

type ConnectionHandlers struct {
	// The maximum number of concurrent connections the server may serve.
	//
	// DefaultConcurrency is used if not set.
	Network          string        `json:"network"`
	Address          string        `json:"address"`
	Concurrency      int           `json:"concurrency"`
	KeepAlive        time.Duration `json:"keepAlive"`
	HandshakeTimeout time.Duration `json:"handshakeTimeout"`
	TLSConfig        *tls.Config
}

func (ch *ConnectionHandlers) Listener(serverCtx ServerCtx) (net.Listener, error) {
	l, err := net.Listen(ch.Network, ch.Address)
	if nil != err {
		return nil, err
	}

	return l, nil
}

func (ch *ConnectionHandlers) GetConcurrency() int {
	return ch.Concurrency
}

func (ch *ConnectionHandlers) GetKeepAlive() time.Duration {
	return ch.KeepAlive
}

func (ch *ConnectionHandlers) GetHandshakeTimeout() time.Duration {
	return ch.HandshakeTimeout
}

func (ch *ConnectionHandlers) GetTLSConfig() *tls.Config {
	return ch.TLSConfig
}

func (ch *ConnectionHandlers) Clone() *ConnectionHandlers {
	return &ConnectionHandlers{
		Network:          ch.Network,
		Address:          ch.Address,
		Concurrency:      ch.Concurrency,
		KeepAlive:        ch.KeepAlive,
		HandshakeTimeout: ch.HandshakeTimeout,
		TLSConfig:        ch.TLSConfig,
	}
}

func (ch *ConnectionHandlers) Validate() error {
	if ch.Concurrency <= 0 {
		ch.Concurrency = DefaultConcurrency
	} else {

	}

	if ch.KeepAlive <= 0 {
		ch.KeepAlive = DefaultKeepAlive
	} else {
		ch.KeepAlive = ch.KeepAlive * time.Second
	}

	if ch.HandshakeTimeout <= 0 {
		ch.HandshakeTimeout = DefaultHandshakeTimeout
	} else {
		ch.HandshakeTimeout = ch.HandshakeTimeout * time.Second
	}

	return nil
}