package appState

import (
	"sync/atomic"
	pb "task-processor/proto/taskProcessor"
	"time"
)

type State struct {
	appStart            int64
	lastCheck           atomic.Int64
	tasksReceived       atomic.Int32
	tasksInProgress     atomic.Int32
	tasksFirstTry       atomic.Int32
	tasksDoneAfterRetry atomic.Int32
	tasksFailed         atomic.Int32
	workStatus          atomic.Int32
	numCPUs             int32
	checkPeriod         int32
	RetriesCount        int
	retriesMinutes      int32
}

func NewState(numCPUs, checkPeriod, retriesCount, retriesMinutes int) *State {
	now := time.Now().Unix()

	state := &State{
		appStart:       now,
		numCPUs:        int32(numCPUs),
		checkPeriod:    int32(checkPeriod),
		RetriesCount:   retriesCount,
		retriesMinutes: int32(retriesMinutes),
	}

	state.lastCheck.Store(now)
	return state
}

func (s *State) ResetCounters() {
	s.tasksReceived.Store(0)
	s.tasksInProgress.Store(0)
	s.tasksFirstTry.Store(0)
	s.tasksDoneAfterRetry.Store(0)
	s.tasksFailed.Store(0)
}

func (s *State) SetStatus(status Status) {
	s.workStatus.Store(int32(status))
}

func (s *State) SetLastCheck() {
	s.lastCheck.Store(time.Now().Unix())
}

func (s *State) SetTasksReceived(num int) {
	s.tasksReceived.Swap(int32(num))
	s.tasksInProgress.Swap(int32(num))
}

func (s *State) TaskDone() {
	s.tasksInProgress.Add(-1)
}

func (s *State) FirstTry() {
	s.tasksFirstTry.Add(1)
}

func (s *State) DoneAfterRetry() {
	s.tasksDoneAfterRetry.Add(1)
}

func (s *State) Failed() {
	s.tasksFailed.Add(1)
}

func (s *State) InProgress() bool {
	return s.tasksInProgress.Load() > 0
}

func (s *State) SetIdleStatus() {
	s.workStatus.Store(int32(StatusIdle))
}

func (s *State) StateResponse() *pb.ProcessorStatusResponse {
	return &pb.ProcessorStatusResponse{
		AppStart:            s.appStart,
		LastCheck:           s.lastCheck.Load(),
		TasksReceived:       s.tasksReceived.Load(),
		TasksInProgress:     s.tasksInProgress.Load(),
		TasksFirstTry:       s.tasksFirstTry.Load(),
		TasksDoneAfterRetry: s.tasksDoneAfterRetry.Load(),
		TasksFailed:         s.tasksFailed.Load(),
		WorkStatus:          Status(s.workStatus.Load()).String(),
		NumCPUs:             s.numCPUs,
		CheckPeriod:         s.checkPeriod,
		RetriesCount:        int32(s.RetriesCount),
		RetriesMinutes:      s.retriesMinutes,
	}
}