package scheduler

import (
	"gitee.com/h79/goutils/common/algorithm"
	"sync"
)

type Scheduler struct {
	rm       sync.Mutex
	groups   []*groupScheduled
	groupMod uint32
}

var (
	inst      *Scheduler
	schedOnce sync.Once
)

func Instance() *Scheduler {
	return inst
}

func NewSchedulerCap(groupNum uint32, capacity int) *Scheduler {
	return newScheduler(groupNum, capacity)
}

func NewScheduler(groupNum uint32) *Scheduler {
	return newScheduler(groupNum, 5000)
}

func newScheduler(groupNum uint32, capacity int) *Scheduler {
	if groupNum == 0 {
		groupNum = 20
	}
	if groupNum > 2000 {
		groupNum = 2000
	}
	var i uint32
	var groups = make([]*groupScheduled, groupNum)
	for i = 0; i < groupNum; i++ {
		groups[i] = newGroupScheduled(capacity)
	}
	var sched = &Scheduler{
		groupMod: groupNum,
		groups:   groups,
	}
	schedOnce.Do(func() {
		inst = sched
	})
	return sched
}

func (sched *Scheduler) groupScheduled(group uint32) *groupScheduled {
	sched.rm.Lock()
	defer sched.rm.Unlock()
	return sched.groups[group]
}

func (sched *Scheduler) groupIndex(key string) uint32 {
	id := algorithm.HashCode(key)
	return id % sched.groupMod
}

func (sched *Scheduler) AddTask(task Task) {
	groups := sched.groupScheduled(sched.groupIndex(task.GetId()))
	groups.AddTask(task)
}

func (sched *Scheduler) AddTriggerTask(task Task, trigger Trigger) error {
	groups := sched.groupScheduled(sched.groupIndex(task.GetId()))
	return groups.AddTriggerTask(task, trigger)
}

func (sched *Scheduler) StopTask(schedId string) {
	groups := sched.groupScheduled(sched.groupIndex(schedId))
	groups.StopTask(schedId)
}

func (sched *Scheduler) RemoveTask(schedId string) {
	groups := sched.groupScheduled(sched.groupIndex(schedId))
	groups.RemoveTask(schedId)
}

func (sched *Scheduler) HasTask(schedId string) bool {
	groups := sched.groupScheduled(sched.groupIndex(schedId))
	return groups.HasTask(schedId)
}

func (sched *Scheduler) Run() {
	sched.rm.Lock()
	defer sched.rm.Unlock()
	for i := range sched.groups {
		sched.groups[i].Run()
	}
}