package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"github.com/Jguer/go-alpm/v2"
	log "github.com/sirupsen/logrus"
	"io"
	"net/http"
	"os"
	"somegit.dev/ALHP/ALHP.GO/ent/dbpackage"
	"strings"
)

const (
	APIBase = "https://api.alhp.dev/"
)

var (
	jsonFlag     = flag.Bool("j", false, "output as JSON")
	debugFlag    = flag.Bool("d", false, "enable debug output")
	exitCodeFlag = flag.Bool("e", false, "exit with non-zero if one of your packages is in queue")
)

type JSONOut struct {
	Total    int      `json:"total"`
	Packages []string `json:"packages"`
}

func main() {
	flag.Parse()

	if *debugFlag {
		log.SetLevel(log.DebugLevel)
	}

	h, er := alpm.Initialize("/", "/var/lib/pacman")
	if er != nil {
		log.Errorf("error initializing alpm library: %v", er)
		os.Exit(1)
	}
	defer func(h *alpm.Handle) {
		err := h.Release()
		if err != nil {
			log.Errorf("error releasing alpm library: %v", err)
		}
	}(h)

	db, er := h.LocalDB()
	if er != nil {
		log.Errorf("error initializing alpm library: %v", er)
		os.Exit(1)
	}

	alhpQueue, err := ALHPBuildQueuePkgbase()
	if err != nil {
		log.Errorf("error getting build queue from ALHP api: %v", err)
		os.Exit(1)
	}
	log.Debugf("alhp build queue length: %d", len(alhpQueue))

	var packagesInQueue []string
	for _, pkg := range db.PkgCache().Slice() {
		if Find(alhpQueue, pkg.Base()) != -1 {
			log.Debugf("found package in queue: %s", pkg.Name())
			packagesInQueue = append(packagesInQueue, pkg.Name())
		}
	}

	if len(packagesInQueue) > 0 {
		log.Debugf("found %d of your local packages in queue", len(packagesInQueue))
		if *jsonFlag {
			err = json.NewEncoder(os.Stdout).Encode(JSONOut{
				Total:    len(packagesInQueue),
				Packages: packagesInQueue,
			})
			if err != nil {
				log.Errorf("error encoding JSON: %v", err)
				os.Exit(1)
			}
		} else {
			fmt.Println(strings.Join(packagesInQueue, "\n"))
		}

		if *exitCodeFlag {
			os.Exit(20)
		}
	}
}

func Find[T comparable](arr []T, match T) int {
	for i, v := range arr {
		if v == match {
			return i
		}
	}

	return -1
}

type ThinPackage struct {
	Pkgbase       string                 `json:"pkgbase"`
	Repo          string                 `json:"repo"`
	SplitPackages []string               `json:"split_packages"`
	Status        dbpackage.Status       `json:"status"`
	SkipReason    *string                `json:"skip_reason,omitempty"`
	LTO           dbpackage.Lto          `json:"lto"`
	DebugSymbols  dbpackage.DebugSymbols `json:"debug_symbols"`
	ArchVersion   string                 `json:"arch_version"`
	RepoVersion   string                 `json:"repo_version"`
	BuildDate     *string                `json:"build_date,omitempty"`
	PeakMem       *string                `json:"peak_mem,omitempty"`
}

type PackageResponse struct {
	Packages []*ThinPackage `json:"packages"`
	Total    int            `json:"total"`
	Offset   int            `json:"offset"`
	Limit    int            `json:"limit"`
}

func ALHPBuildQueuePkgbase() ([]string, error) {
	resp, err := http.Get(fmt.Sprintf("%spackages?status=built&status=building&status=queued&limit=0&offset=0", APIBase))
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	bResp, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	jResp := new(PackageResponse)
	if err = json.Unmarshal(bResp, jResp); err != nil {
		return nil, err
	}

	respArray := make([]string, len(jResp.Packages))
	for i := range jResp.Packages {
		respArray[i] = jResp.Packages[i].Pkgbase
	}
	return respArray, nil
}