package main

import (
	"slices"
	"strings"
	"sync"
	"time"

	"src.opensuse.org/autogits/common"
)

var WatchedRepos []string
var mutex sync.Mutex

var StatusUpdateCh chan StatusUpdateMsg = make(chan StatusUpdateMsg)

var statusMutex sync.RWMutex
var CurrentStatus map[string]*common.BuildResultList = make(map[string]*common.BuildResultList)

type StatusUpdateMsg struct {
	ObsProject string
	Result     *common.BuildResultList
}

func GetCurrentStatus(project string) *common.BuildResultList {
	statusMutex.RLock()

	if ret, found := CurrentStatus[project]; found {
		statusMutex.RUnlock()
		return ret
	}

	res, err := obs.BuildStatus(project)
	statusMutex.RUnlock()
	statusMutex.Lock()
	defer statusMutex.Unlock()

	if err != nil {
		return res
	}
	CurrentStatus[project] = res

	now := time.Now().Unix()
	CurrentStatus[project].LastUpdate = now
	for _, r := range res.Result {
		r.LastUpdate = now
		for _, p := range r.Status {
			p.LastUpdate = now
		}
		slices.SortFunc(r.Status, packageSort)
	}
	slices.SortFunc(res.Result, repoSort)
	return res
}


func updatePrjPackage(prjState *common.BuildResultList, pkg string, now int64, pkgState *common.BuildResultList) {
	for prjState.
	Result[0].Status[0].Package
}

func extractPackageBuildStatus(prjState *common.BuildResultList, pkg string) []*common.PackageBuildStatus {

}

func GetDetailedPackageBuildStatus(prj, pkg string) []*common.PackageBuildStatus {
	statusMutex.RLock()
	now := time.Now().Unix()

	cachedPrj, found := CurrentStatus[prj]
	if found {
		statusMutex.Unlock()
		if now-cachedPrj.LastUpdate < 60 {
			return extractPackageBuildStatus(cachedPrj, pkg)
		}
	}

	ret, err := obs.BuildStatus(prj, pkg)
	if err != nil {
		return nil
	}

	statusMutex.Lock()
	defer statusMutex.Unlock()

	updatePrjPackage(cachedPrj, pkg, now, ret)
	return extractPackageBuildStatus(cachedPrj, pkg)
}

func GetDetailedBuildStatus(prj, pkg, repo, arch string) *common.PackageBuildStatus {
	prjStatus := GetCurrentStatus(prj)
	if prjStatus == nil {
		return nil
	}

	for _, r := range prjStatus.Result {
		if r.Arch == arch && r.Repository == repo {
			for _, status := range r.Status {
				if status.Package == pkg {
					return &status
				}
			}
		}
	}

	return nil
}

func ProcessUpdates() {
	for {
		msg := <-StatusUpdateCh

		statusMutex.Lock()
		CurrentStatus[msg.ObsProject] = msg.Result

	drainedChannel:
		for {
			select {
			case msg = <-StatusUpdateCh:
				CurrentStatus[msg.ObsProject] = msg.Result
			default:
				statusMutex.Unlock()
				break drainedChannel
			}
		}
	}
}