package svalue

import (
	"errors"
	"log"
	"reflect"
	"runtime"
	"sync"
	"time"
)

// IValue 必须实现的值接口
type IValue interface {
	// TakeValue 获取 value的方法覆盖
	TakeValue() interface{}

	// 每次 TakeValue 休眠的时间
	UpdateInterval() time.Duration

	// Lock value的锁
	Lock()
	// Unlock value的解锁
	Unlock()

	// SetValue 设置动态的值 TakeValue 调用
	SetValue(v interface{})

	Close()
	IsClose() bool

	SetSync(is bool)
	IsSync() bool
}

// Value 必须设置的动态类型
type Value struct {
	IValue

	value interface{}
	mutex sync.Mutex

	isClose bool
	isSync  bool
}

func (value *Value) SetValue(v interface{}) {
	value.value = v
}

func (value *Value) Lock() {
	value.mutex.Lock()
}

func (value *Value) Unlock() {
	value.mutex.Unlock()
}

func (value *Value) IsSync() bool {
	return value.isSync
}

func (value *Value) SetSync(is bool) {
	value.isSync = is
}

func (value *Value) Value() interface{} {
	value.mutex.Lock()
	defer value.mutex.Unlock()
	return value.value
}

func (value *Value) Close() {
	value.mutex.Lock()
	defer value.mutex.Unlock()
	value.isClose = true
}

func (value *Value) IsClose() bool {
	return value.isClose
}

func (value *Value) TakeUpdateInterval() time.Duration {
	return time.Second * 5
}

func StartSynchronize(value IValue) bool {
	if !reflect.ValueOf(value.TakeValue).CanInterface() {
		panic(errors.New("TakeValue method is need OverWrite"))
	}

	runtime.SetFinalizer(value, func(obj IValue) {
		obj.Close()
	})

	if value.IsSync() {
		return false
	}

	go func() {

		for {

			value.Lock()

			value.SetValue(value.TakeValue())
			isClose := value.IsClose()

			value.Unlock()

			if isClose {
				log.Println(value, "is Closed")
				break
			}
			time.Sleep(value.UpdateInterval())
			if isClose {
				log.Println(value, "is Closed")
				break
			}

		}

	}()

	value.SetSync(true)
	return true
}