package core

import (
	"github.com/google/uuid"
	"github.com/sirupsen/logrus"
	"sync"
	"time"
)

type Tracking struct {
	TrackingMetadata
	Records []recordPair
	Rawdata []rawRecord
}

var mRec sync.RWMutex
var mRaw sync.RWMutex

type TrackingMetadata struct {
	UUID        uuid.UUID
	TimeCreated time.Time
	Collectors  []CollectorType
}

// persistence wrapper for sensordata
type recordPair struct {
	RecordTimeKey time.Time // uniqueness ensured through mutex
	DataPair      map[sourceId]sensorData
}

type rawRecord struct {
	RecordTimeKey time.Time // uniqueness ensured through mutex
	Data          sensorData
}

// END persistence wrapper for sensordata

func (s *Tracking) EnqueuePair(tcp sensorData, ser sensorData) {
	rp := recordPair{
		RecordTimeKey: time.Now(),
		DataPair: map[sourceId]sensorData{
			tcp.source: tcp,
			ser.source: ser,
		},
	}
	mRec.Lock()
	s.Records = append(s.Records, rp)
	logrus.Debugln("tracking Records: len->", len(s.Records))
	mRec.Unlock()
}

func (s *Tracking) EnqueueRaw(data sensorData) {
	sr := rawRecord{
		time.Now(),
		data,
	}
	mRec.Lock()
	s.Rawdata = append(s.Rawdata, sr)
	logrus.Debugln("raw data points: len->", len(s.Rawdata))
	mRec.Unlock()
}

func emptyTracking() Tracking {
	return Tracking{
		TrackingMetadata: TrackingMetadata{
			UUID: uuid.New(),
		},
		Records: []recordPair{},
		Rawdata: []rawRecord{},
	}
}

func (s *Tracking) isEmpty() bool {
	return len(s.Rawdata)+len(s.Records) == 0
}