package notify

type logicalSessionState struct {
	pendingWaits        *pendingWaitPool
	fileReceives        *fileReceivePool
	fileAckWaits        *fileAckPool
	signalAckWaits      *signalAckPool
	receivedSignals     *receivedSignalCache
	signalReliableState *signalReliabilityState
	fileTransfers       *fileTransferState
	transfers           *transferState
}

func newLogicalSessionState(fileCfg fileTransferConfig, signalCfg signalReliabilityConfig) *logicalSessionState {
	fileCfg = normalizeFileTransferConfig(fileCfg)
	signalCfg = normalizeSignalReliabilityConfig(signalCfg)
	return &logicalSessionState{
		pendingWaits:        newPendingWaitPool(),
		fileReceives:        newFileReceivePoolWithConfig(fileCfg),
		fileAckWaits:        newFileAckPool(),
		signalAckWaits:      newSignalAckPool(),
		receivedSignals:     newReceivedSignalCache(signalCfg.ReceiveCacheLimit),
		signalReliableState: newSignalReliabilityState(),
		fileTransfers:       newFileTransferStateWithConfig(fileCfg),
		transfers:           newTransferState(),
	}
}

func (s *logicalSessionState) applyFileTransferConfig(cfg fileTransferConfig) {
	if s == nil {
		return
	}
	cfg = normalizeFileTransferConfig(cfg)
	if s.fileReceives != nil {
		s.fileReceives.applyConfig(cfg)
	}
	if s.fileTransfers != nil {
		s.fileTransfers.applyConfig(cfg)
	}
}

func (s *logicalSessionState) applySignalReliabilityConfig(cfg signalReliabilityConfig) {
	if s == nil {
		return
	}
	cfg = normalizeSignalReliabilityConfig(cfg)
	if s.receivedSignals != nil {
		s.receivedSignals.applyLimit(cfg.ReceiveCacheLimit)
	}
}

func (c *ClientCommon) getLogicalSessionState() *logicalSessionState {
	c.mu.Lock()
	fileCfg := normalizeFileTransferConfig(c.fileTransferCfg)
	signalCfg := normalizeSignalReliabilityConfig(c.signalReliableCfg)
	c.fileTransferCfg = fileCfg
	c.signalReliableCfg = signalCfg
	if c.logicalSession == nil {
		c.logicalSession = newLogicalSessionState(fileCfg, signalCfg)
	}
	state := c.logicalSession
	c.mu.Unlock()
	state.applyFileTransferConfig(fileCfg)
	state.applySignalReliabilityConfig(signalCfg)
	return state
}

func (s *ServerCommon) getLogicalSessionState() *logicalSessionState {
	s.mu.Lock()
	fileCfg := normalizeFileTransferConfig(s.fileTransferCfg)
	signalCfg := normalizeSignalReliabilityConfig(s.signalReliableCfg)
	s.fileTransferCfg = fileCfg
	s.signalReliableCfg = signalCfg
	if s.logicalSession == nil {
		s.logicalSession = newLogicalSessionState(fileCfg, signalCfg)
	}
	state := s.logicalSession
	s.mu.Unlock()
	state.applyFileTransferConfig(fileCfg)
	state.applySignalReliabilityConfig(signalCfg)
	return state
}

func (c *ClientCommon) getTransferState() *transferState {
	return c.getLogicalSessionState().transfers
}

func (s *ServerCommon) getTransferState() *transferState {
	return s.getLogicalSessionState().transfers
}