package gogo

import (
	"reflect"
	"sync"
)

type TaskModel struct {
	mEndRunning  chan int
	mQueue       chan interface{}
	mTaskClass   interface{}
	mMaxGoCount  int
	mTempGoCount int
	mMutex       sync.Mutex
}

func (c *TaskModel) addGo() bool {
	c.mMutex.Lock()
	defer c.mMutex.Unlock()

	if c.mTempGoCount < c.mMaxGoCount {
		c.mTempGoCount += 1
		return true
	}

	return false
}

func (c *TaskModel) delGo() int {
	c.mMutex.Lock()
	defer c.mMutex.Unlock()

	if c.mTempGoCount >= 1 {
		c.mTempGoCount -= 1
	} else {
		c.mTempGoCount = 0
	}

	return c.mTempGoCount
}

func (c *TaskModel) waitGo() {
	for {
		if c.addGo() {
			return
		}
		TimeSleepMilliSecond(100)
		continue
	}
}

func (c *TaskModel) start() {
	go func() {
		val := reflect.ValueOf(c.mTaskClass)
		tFunc := val.MethodByName("Proc")
		args := make([]reflect.Value, 1)

		for data := range c.mQueue {
			c.waitGo()
			args[0] = reflect.ValueOf(data)
			go func() {
				tFunc.Call(args)
				c.delGo()
			}()
		}
	}()
}

func (c *TaskModel) release() {
	for range c.mEndRunning {
	}

	val := reflect.ValueOf(c.mTaskClass)
	tFunc := val.MethodByName("Release")
	args := make([]reflect.Value, 0)
	tFunc.Call(args)
}

// NewTask 新建一个多协程并发任务;
// taskClass: 将自定义函数命名为“Proc”，且参数只有一个，然后通过struct封装成类，taskClass参数就是这个类;
// count: 队列最大缓存数据量，如果多协程并发任务来不及处理，该队列数据量会增加，需要限制最高值;
// max_go: 最大的并发协程数量限制;
// handler HttpProcFunc: 触发函数.
func NewTask(taskClass interface{}, count, max_go int) *TaskModel {
	r := &TaskModel{
		mEndRunning:  make(chan int),
		mQueue:       make(chan interface{}, count),
		mTaskClass:   taskClass,
		mMaxGoCount:  max_go,
		mTempGoCount: 0,
	}

	r.start()
	return r
}

// SetMaxGoCount 修改最大的并发协程数量限制
func (c *TaskModel) SetMaxGoCount(maxGoCount int) {
	c.mMutex.Lock()
	defer c.mMutex.Unlock()

	c.mMaxGoCount = maxGoCount
}

// Push 提交数据给多协程并发任务
func (c *TaskModel) Push(data interface{}) error {
	c.mQueue <- data
	return nil
}

// SendRelease 结束多协程并发任务
func (c *TaskModel) SendRelease() {
	close(c.mQueue)
	c.release()
}