package socket

import (
	"sync/atomic"
	"time"

	"git.loafle.net/commons/server-go"
)

type ReadWriteHandler interface {
	server.ReadWriteHandler
	GetPongTimeout() time.Duration
	GetPingTimeout() time.Duration
	GetPingPeriod() time.Duration

	IsEnableCompression() bool
}

type ReadWriteHandlers struct {
	server.ReadWriteHandlers

	PongTimeout time.Duration `json:"pongTimeout,omitempty"`
	PingTimeout time.Duration `json:"pingTimeout,omitempty"`
	PingPeriod  time.Duration `json:"pingPeriod,omitempty"`

	EnableCompression bool `json:"enableCompression,omitempty"`

	validated atomic.Value
}

func (rwh *ReadWriteHandlers) GetPongTimeout() time.Duration {
	return rwh.PongTimeout
}
func (rwh *ReadWriteHandlers) GetPingTimeout() time.Duration {
	return rwh.PingTimeout
}
func (rwh *ReadWriteHandlers) GetPingPeriod() time.Duration {
	return rwh.PingPeriod
}
func (rwh *ReadWriteHandlers) IsEnableCompression() bool {
	return rwh.EnableCompression
}

func (rwh *ReadWriteHandlers) Clone() *ReadWriteHandlers {
	return &ReadWriteHandlers{
		ReadWriteHandlers: *rwh.ReadWriteHandlers.Clone(),
		PongTimeout:       rwh.PongTimeout,
		PingTimeout:       rwh.PingTimeout,
		PingPeriod:        rwh.PingPeriod,
		EnableCompression: rwh.EnableCompression,
		validated:         rwh.validated,
	}
}

func (rwh *ReadWriteHandlers) Validate() error {
	if nil != rwh.validated.Load() {
		return nil
	}
	rwh.validated.Store(true)

	if err := rwh.ReadWriteHandlers.Validate(); nil != err {
		return err
	}

	if rwh.PongTimeout <= 0 {
		rwh.PongTimeout = server.DefaultPongTimeout
	} else {
		rwh.PongTimeout = rwh.PongTimeout * time.Second
	}

	if rwh.PingTimeout <= 0 {
		rwh.PingTimeout = server.DefaultPingTimeout
	} else {
		rwh.PingTimeout = rwh.PingTimeout * time.Second
	}
	if rwh.PingPeriod <= 0 {
		rwh.PingPeriod = (rwh.PingTimeout * 9) / 10
	} else {
		rwh.PingPeriod = rwh.PingPeriod * time.Second
	}

	return nil
}