package ruleserver

import (
	"fmt"
	"os"
	"ruleprocess/logger"
	"time"
)

var stopChan = make(chan bool)

// 计数器map 独立任务的键是任务id拼接区域id 联动任务的键是groupid（能不能都用groupId?）
var TimeEleList = make(map[string]*TimeElement)

// 定时器元素
type TimeElement struct {
	N           int     // 按时间依次递减的当前值
	InitN       int     // 赋值后就不变的初始值
	Data        AreaMap //
	GroupId     string  // 联动规则需要记录下此时的规则组id
	RuleResults []*RuleResult
}
type RuleResult struct { // 每个摄像机一个结构体
	CameraId    string // 摄像机id
	Sort        int32  // 摄像机在规则组中序号
	Result      string // 摄像机过滤数据得出的结果
	RuleWithPre string // 摄像机之间的连接符
}

func TimeTicker() {
	logger.Info("定时器执行了")
	fmt.Println("定时器执行了")
	ticker := time.NewTicker(1 * time.Second)
	go func(ticker *time.Ticker) {
		defer ticker.Stop()
		for {
			select {
			case <-ticker.C:
				logger.Info("定时器执行单元",time.Now().Unix())
				fmt.Println("定时器执行单元",time.Now().Unix())
				// 每秒钟计数器池子里所有的计数器元素都减一，减到0的是该报警的
				for _, timeEle := range TimeEleList {
					if timeEle.N > 0 {
						timeEle.N = timeEle.N - 1
						logger.Info("-------------------------------------打印定时器元素当前值-----------------------------------------：",timeEle.N)
					}
				}
			case stop := <-stopChan:
				if stop {
					logger.Info("定时器结束")
					os.Exit(0)
				}
			}
		}
	}(ticker)
}
func StopTimeTicker() {
	stopChan <- true
	TimeTicker()
}

// 定时器单元  废弃版本
// func TimeTicker() chan bool {
// 	logger.Info("执行了timeTicker")
// 	ticker := time.NewTicker(1 * time.Second)
// 	stopChan := make(chan bool)
// 	go func(ticker *time.Ticker) {
// 		defer ticker.Stop()
// 		for {
// 			select {
// 			case <-ticker.C:
// 				//logger.Info("执行单元", "计数器集合2", TimeEleList)
// 				for k, timeEle := range TimeEleList {
// 					timeEle.n = timeEle.n - 1
// 					//logger.Info("遍历的数值", TimeEleList)
// 					if timeEle.n == 0 {
// 						// do something alarm
// 						alarm(k, timeEle)
// 					}
// 				}
// 			case stop := <-stopChan:
// 				if stop {
// 					logger.Info("定时器结束")
// 					return
// 				}
// 			}
// 		}
// 	}(ticker)
// 	return stopChan
// }

// 结构体根据某字段排序
type SubList []*RuleResult

func (p SubList) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p SubList) Len() int           { return len(p) }
func (p SubList) Less(i, j int) bool { return p[i].Sort < p[j].Sort }

// 结构体根据某字段排序
type resultList []*LittleRuleResult

func (p resultList) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p resultList) Len() int           { return len(p) }
func (p resultList) Less(i, j int) bool { return p[i].Sort < p[j].Sort }