/*
==================================================================================
  Copyright (c) 2019 AT&T Intellectual Property.
  Copyright (c) 2019 Nokia

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
==================================================================================
*/
/*
Timer takes four parameters:
	 1) strId 			string   			'string format timerMap key'
	 2) nbrId 			int      			'numeric format timerMap key'
	 3) timerDuration	time.Duration  		'timer duration'
	 4) timerFunction	func(string, int) 	'function to be executed when timer expires'

	Timer function is put inside in-build time.AfterFunc() Go function, where it is run inside own Go routine
	when the timer expires. Timer are two key values. Both are used always, but the other one can be left
	"empty", i.e. strId = "" or  nbrId = 0. Fourth parameter, the timer function is bare function name without
	any function parameters and parenthesis! Filling first parameter strId with related name can improve
	code readability and robustness, even the numeric Id would be enough from functionality point of view.

	TimerStart() function starts the timer. If TimerStart() function is called again with same key values
	while earlier started timer is still in the timerMap, i.e. it has not been stopped or the timer has not
	yet expired, the old timer is deleted and new timer is started with the given time value.

	StopTimer() function stops the timer. There is no need to call StopTimer() function after the timer has
	expired. Timer is removed automatically from the timeMap. Calling StopTimer() function with key values not
	existing in the timerMap, has no effect.

	NOTE: Each timer is run in separate Go routine. Therefore, the function that is executed when timer expires
	MUST be designed to be able run concurrently! Also, function run order of simultaneously expired timers cannot
	guaranteed anyway!

	If you need to transport more information to the timer function, consider to use another map to store the
	information with same key value, as the started timer.

	Init timerMap example:
		timerMap := new(TimerMap)
		timerMap.Init()

	StartTimer() and StartTimer() function usage examples.
	1)
		subReqTime := 2 * time.Second
		subId := 123
		timerMap.StartTimer("RIC_SUB_REQ", int(subId), subReqTime, handleSubscriptionRequestTimer)
		timerMap.StopTimer("RIC_SUB_REQ", int(subId))

	2)
		subReqTime := 2 * time.Second
		strId := "1UHSUwNqxiVgUWXvC4zFaatpZFF"
		timerMap.StartTimer(strId, 0, subReqTime, handleSubscriptionRequestTimer)
		timerMap.StopTimer(strId, 0)

	3)
		subReqTime := 2 * time.Second
		strId := "1UHSUwNqxiVgUWXvC4zFaatpZFF"
		timerMap.StartTimer(RIC_SUB_REQ_" + strId, 0, subReqTime, handleSubscriptionRequestTimer)
		timerMap.timerMap.StopTimer("RIC_SUB_REQ_" + strId, 0)

	Timer function example. This is run if any of the above started timer expires.
		func handleSubscriptionRequestTimer1(strId string, nbrId int) {
			fmt.Printf("Subscription Request timer expired. Name: %v, SubId: %v\n",strId, nbrId)
		}
*/

package control

import (
	"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
	"sync"
	"time"
)

type TimerKey struct {
	strId string
	nbrId int
}

type TimerInfo struct {
	timerAddress         *time.Timer
	timerFunctionAddress func()
}

type TimerMap struct {
	timer map[TimerKey]TimerInfo
	mutex sync.Mutex
}

// This method should run as a constructor
func (t *TimerMap) Init() {
	t.timer = make(map[TimerKey]TimerInfo)
}

func (t *TimerMap) StartTimer(strId string, nbrId int, expireAfterTime time.Duration, timerFunction func(srtId string, nbrId int)) bool {
	t.mutex.Lock()
	defer t.mutex.Unlock()
	if timerFunction == nil {
		xapp.Logger.Error("StartTimer() timerFunc == nil\n")
		return false
	}
	timerKey := TimerKey{strId, nbrId}
	// Stop timer if there is already timer running with the same id
	if val, ok := t.timer[timerKey]; ok {
		xapp.Logger.Debug("StartTimer() old timer found")
		if val.timerAddress != nil {
			xapp.Logger.Debug("StartTimer() deleting old timer")
			val.timerAddress.Stop()
		}
		delete(t.timer, timerKey)
	}

	// Store in timerMap in-build Go "timer", timer function executor, and the function to be executed when the timer expires
	t.timer[timerKey] = TimerInfo{timerAddress: time.AfterFunc(expireAfterTime, func() { t.timerFunctionExecutor(strId, nbrId) }),
		timerFunctionAddress: func() { timerFunction(strId, nbrId) }}
	return true
}

func (t *TimerMap) StopTimer(strId string, nbrId int) bool {
	t.mutex.Lock()
	defer t.mutex.Unlock()
	timerKey := TimerKey{strId, nbrId}
	if val, ok := t.timer[timerKey]; ok {
		if val.timerAddress != nil {
			val.timerAddress.Stop()
			delete(t.timer, timerKey)
			return true
		} else {
			xapp.Logger.Error("StopTimer() timerAddress == nil")
			return false
		}
	} else {
		xapp.Logger.Debug("StopTimer() Timer not found. May be expired or stopped already. timerKey.strId: %v, timerKey.strId: %v\n", timerKey.strId, timerKey.nbrId)
		return false
	}
}

func (t *TimerMap) timerFunctionExecutor(strId string, nbrId int) {
	t.mutex.Lock()
	timerKey := TimerKey{strId, nbrId}
	if val, ok := t.timer[timerKey]; ok {
		if val.timerFunctionAddress != nil {
			// Take local copy of timer function address
			f := val.timerFunctionAddress
			// Delete timer instance from map
			delete(t.timer, timerKey)
			t.mutex.Unlock()
			// Execute the timer function
			f()
			return
		} else {
			xapp.Logger.Error("timerExecutorFunc() timerFunctionAddress == nil")
			t.mutex.Unlock()
			return
		}
	} else {
		xapp.Logger.Error("timerExecutorFunc() Timer is not anymore in map. timerKey.strId: %v, timerKey.strId: %v\n", timerKey.strId, timerKey.nbrId)
		t.mutex.Unlock()
		return
	}
}