package f5

import (
	"q5"
)

type taskLock struct {
	key string
	entry q5.ListHead
}

type AsyncTask struct {
	status int32
	cb func(*AsyncTask)
	succCb func(*AsyncTask)
	failCb func(*AsyncTask)
	execTimes int64
	lockKeys map[string]*taskLock
}

type LockAsyncTask = AsyncTask

func (this *AsyncTask) init(cb func(*AsyncTask)) *AsyncTask {
	this.cb = cb
	return this
}

func (this *AsyncTask) GetExecTimes() int64 {
	return this.execTimes
}

func (this *AsyncTask) IsRunning() bool {
	return this.status == 0
}

func (this *AsyncTask) IsSucc() bool {
	return this.status > 0
}

func (this *AsyncTask) IsFail() bool {
	return this.status < 0
}

func (this *AsyncTask) SetSucc() {
	if !this.IsRunning() {
		panic("task is not runing")
	}
	this.status = 1
	if this.succCb != nil {
		this.succCb(this)
	}
}

func (this *AsyncTask) SetFail() {
	if !this.IsRunning() {
		panic("task is not runing")
	}
	this.status = -1
	if this.failCb != nil {
		this.failCb(this)
	}
}

func (this *AsyncTask) Continue() *AsyncTask {
	if !this.IsRunning() {
		panic("task is not runing")
	}
	GetApp().RegisterMainThreadCb(
		func () {
			this.cb(this)
			this.execTimes += 1
		})
	return this
}

func (this *AsyncTask) checkDo() *AsyncTask {
	if !this.IsRunning() {
		panic("task is not runing")
	}
	if this.allIsReady() {
		GetApp().RegisterMainThreadCb(
			func () {
				this.cb(this)
				this.execTimes += 1
			})
	}
	return this
}

func (this *AsyncTask) OnSucc(cb func(*AsyncTask)) *AsyncTask {
	this.ClearLocks()
	this.succCb = cb
	return this
}

func (this *AsyncTask) OnFail(cb func(*AsyncTask)) *AsyncTask {
	this.ClearLocks()
	this.failCb = cb
	return this
}

func (this *AsyncTask) allIsReady() bool {
	var allReady = true
	for _, lock := range(this.lockKeys) {
		if !_app.isFirstAsyncTask(lock.key, &lock.entry) {
			allReady = false
			break
		}
	}
	return allReady
}

func (this *AsyncTask) ClearLocks() {
	for _, lock := range(this.lockKeys) {
		lock.entry.DelInit()
	}
	for _, lock := range(this.lockKeys) {
		_app.clearEmptyPendingAsyncTask(lock.key)
	}
	for _, lock := range(this.lockKeys) {
		_app.notifyNextTask(lock.key)
	}
}

func NewAsyncTask(cb func(*AsyncTask)) *AsyncTask {
	p := new(AsyncTask)
	p.lockKeys = make(map[string]*taskLock)
	return p.init(cb).Continue()
}

func NewLockAsyncTask(keys [][]string, cb func(*LockAsyncTask)) *LockAsyncTask {
	p := new(AsyncTask)
	p.lockKeys = make(map[string]*taskLock)
	for _, val := range(keys) {
		if len(val) != 2 {
			panic("NewLockAsyncTask len error:" + q5.EncodeJson(val))
		}
		lock := new(taskLock)
		lock.key = val[0] + val[1]
		lock.entry.Init(p)
		if _, ok := p.lockKeys[lock.key]; ok {
			panic("NewLockAsyncTask duplicate key:" + lock.key)
		}
		p.lockKeys[lock.key] = lock
		_app.forcePendingAsyncTask(lock.key).AddTail(&lock.entry)
	}
	return p.init(cb).checkDo()
}