package main

import (
	"context"
	"modbusmock/logger"

	"time"
)

func main() {
	mConfig, err := NewConfig()
	if err != nil {
		logger.Errorf("[modbus-mock]->main NewConfig error:%v", err)
		panic(err)
	}

	var tcpDeviceModels = make([]*DeviceModel, 0)
	if err := ParseConfig(&tcpDeviceModels, mConfig.Modbus.TCP); err != nil {
		logger.Errorf("[modbus-mock]->main ParseConfig tcp error:%v", err)
		panic(err)
	}

	var rtuDeviceModels = make([]*DeviceModel, 0)
	if err := ParseConfig(&rtuDeviceModels, mConfig.Modbus.RTU); err != nil {
		logger.Errorf("[modbus-mock]->main ParseConfig rtu error:%v", err)
		panic(err)
	}

	var withContext context.Context
	var concelFunc context.CancelFunc

	if mConfig.Service.Timeout <= 0 {
		withContext, concelFunc = context.WithCancel(context.Background())
	} else {
		withContext, concelFunc = context.WithTimeout(context.Background(), time.Duration(mConfig.Service.Timeout)*time.Second)
	}
	defer concelFunc()

	devicePool := OpenDevicePool(withContext)

	// add tcp device request
	tcpModbusReqs := FillModbusReq(tcpDeviceModels, tcpDeviceProtocol)
	// add rtu device request
	rtuModbusReqs := FillModbusReq(rtuDeviceModels, rtuDeviceProtocol)

	// work start
	logger.Infof("[modbus-mock]->request start time:%v", time.Now().UnixNano()/1e6)
	for _, tcpDM := range tcpModbusReqs {
		devicePool.openerCh <- tcpDM
	}

	// add rtu device request
	for _, rtuDM := range rtuModbusReqs {
		devicePool.openerCh <- rtuDM
	}

	for {
		select {
		case <-withContext.Done():
			logger.Infof("[modbus-mock]->request end time:%v", time.Now().UnixNano()/1e6)
			logger.Infof("[modbus-mock]->main done: %v", withContext.Err())
			return
		default:
		}
	}

}