package scheduler

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

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

var (
	inst *Scheduler
	once sync.Once
)

func WithTaskDuration(t time.Duration) option.Option {
	return option.WithOpt(t, "", 1)
}

func Instance(opts ...option.Option) *Scheduler {
	once.Do(func() {
		inst = newScheduler(20, 2000, opts...)
	})
	return inst
}

func NewSchedulerCap(groupNum uint32, capacity int, opts ...option.Option) *Scheduler {
	return newScheduler(groupNum, capacity, opts...)
}

func NewScheduler(groupNum uint32, opts ...option.Option) *Scheduler {
	return newScheduler(groupNum, 5000, opts...)
}

func newScheduler(groupNum uint32, capacity int, opts ...option.Option) *Scheduler {
	if groupNum == 0 {
		groupNum = 20
	}
	if groupNum > 2000 {
		groupNum = 2000
	}
	var taskDuration = option.Select(1, time.Millisecond*10, opts...)
	var i uint32
	var groups = make([]*groupScheduled, groupNum)
	for i = 0; i < groupNum; i++ {
		groups[i] = newGroupScheduled(capacity, taskDuration)
	}
	return &Scheduler{
		groupMod: groupNum,
		groups:   groups,
	}
}

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) UpdateTask(schedId string, update func(task Task) bool) bool {
	groups := sched.groupScheduled(sched.groupIndex(schedId))
	return groups.UpdateTask(schedId, update)
}

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()
	}
}