package sfive

import (
	"time"
)

// compared to JSON DTOs, DB types are flattened, and use key-relations instead of collections
// this is very much not normalized at all, because I'm too lazy to type

// table names
const (
	tagsTn              = "Tags"
	sourceTagsTn        = "StreamToTagMap"
	sourcesTn           = "Sources"
	clientdataUpdatesTn = "ClientDataUpdates"
	dataUpdatesTn       = "DataUpdates"
	hubInfoTn           = "HubInfo"
)

type hubInfoDb struct {
	Name  string
	Value string
}

// stored in tagsTn
type tagDb struct {
	Id   int
	Name string
}

// stored in sourceTagsTn
// Stream m:n Tag
type sourceTagsDb struct {
	TagId    int // foreign key to tagsTn
	SourceId int // foreign key to sourcesTn
}

// stored in sourcesTn
type sourceDb struct {
	Id int
	StreamId
	SourceId
}

// stored in clientdataUpdatesTn
// ClientData n:1 DataUpdate
type clientDataDb struct {
	Id            int
	DataUpdatesId int // foreign key to dataUpdatesTn
	ClientData
}

// stored in dataUpdatesTn
// in DB, StatisticsData/DataUpdate is flattened compared to JSON DTOs
type dataUpdateDb struct {
	Id                    int
	SourceId              int // foreign key to sourcesTn
	SourceHubUuid         *string
	SourceHubDataUpdateId *int
	StartTime             int64 // time.Time
	Duration              int64 // duration in milliseconds
	ClientCount           uint
	BytesReceived         uint
	BytesSent             uint
}

func (self *SourceId) CopyFromSourceDb(value sourceDb) {
	self.Version = value.Version
	self.Hostname = value.Hostname
	self.StreamId.ContentId = value.ContentId
	self.StreamId.Format = value.Format
	self.StreamId.Quality = value.Quality
}

func (self *SourceId) CopyFromTagsDb(values []tagDb) {
	tags := make([]string, len(values))
	for i := range values {
		tags[i] = values[i].Name
	}
	self.Tags = tags
}

func (self *StatisticsData) CopyFromDataUpdateDb(value dataUpdateDb, hubId string) {
	if value.SourceHubUuid == nil {
		self.SourceHubUuid = &hubId
	} else {
		self.SourceHubUuid = value.SourceHubUuid
	}
	if value.SourceHubDataUpdateId == nil {
		self.SourceHubDataUpdateId = &value.Id
	} else {
		self.SourceHubDataUpdateId = value.SourceHubDataUpdateId
	}

	self.StartTime = time.Unix(value.StartTime, 0)
	self.Duration = value.Duration
	self.Data.ClientCount = value.ClientCount
	self.Data.BytesReceived = value.BytesReceived
	self.Data.BytesSent = value.BytesSent
}

func (self *StatisticsData) CopyFromClientDataDb(values []clientDataDb) {
	clients := make([]ClientData, len(values))
	for i := range values {
		clients[i].Ip = values[i].Ip
		clients[i].UserAgent = values[i].UserAgent
		clients[i].BytesSent = values[i].BytesSent
	}
	self.Data.Clients = clients
}

func cvtToApiStatisticsData(
	hubId string, source sourceDb, update dataUpdateDb, clients []clientDataDb, tags []tagDb) StatisticsData {
	res := StatisticsData{}
	res.CopyFromSourceDb(source)
	res.CopyFromDataUpdateDb(update, hubId)
	res.CopyFromClientDataDb(clients)
	res.CopyFromTagsDb(tags)
	return res
}