package core

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

var m1 sync.RWMutex
var m2 sync.RWMutex

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

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

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

func (s *Tracking) EnqueueRaw(data sensorData) {
    sr := rawRecord{
        time.Now(),
        data,
    }
    m1.Lock()
    s.Rawdata = append(s.Rawdata, sr)
    logrus.Debugln("raw data points: len->", len(s.Rawdata))
    m1.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
}