package main

import (
	"context"
)

type deviceProtoctlType uint8

const (
	tcpDeviceProtocol deviceProtoctlType = iota
	rtuDeviceProtocol
)

var (
	connectionRequestQueueSize uint32 = 100
)

type DevicePool struct {
	deqChan  chan *DeviceRequest
	openerCh chan *DeviceRequest
	ctx      context.Context
}

func OpenDevicePool(parentCtx context.Context) *DevicePool {
	devicePool := &DevicePool{
		deqChan:  make(chan *DeviceRequest, 1),
		openerCh: make(chan *DeviceRequest, connectionRequestQueueSize),
		ctx:      parentCtx,
	}
	//生产 conn
	go devicePool.connectionOpener()

	//消费 conn
	go devicePool.runConnDevice()

	return devicePool
}

func (devicePool *DevicePool) connectionOpener() {
	for {
		select {
		case <-devicePool.ctx.Done():
			return
		case d := <-devicePool.openerCh:
			devicePool.deqChan <- &DeviceRequest{
				ModpollParams: d.ModpollParams,
			}
		}
	}
}

func (devicePool *DevicePool) runConnDevice() error {
	for {
		select {
		default:
		case device, ok := <-devicePool.deqChan:
			if ok && device != nil {
				deviceQ := &DeviceRequest{
					ModpollParams: device.ModpollParams,
				}
				go deviceQ.Exec(devicePool.ctx)
			}
		case <-devicePool.ctx.Done():
			return devicePool.ctx.Err()
		}
	}

	return nil
}