package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"os/exec"
	"strings"

	"git.skdevstudios.com/specCon18/reforgerds-updater/internal/a2s"
)

type Update struct {
	Version   string `json:"version"`
	Build     string `json:"build"`
	Published string `json:"published"`
}

const (
	updateURL     = "http://127.0.0.1:3000/updates"
	stateFilePath = "latest_version.txt"
)

func main() {
	resp, err := http.Get(updateURL)
	if err != nil {
		fmt.Printf("Failed to fetch updates: %v\n", err)
		return
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)

	var updates []Update
	err = json.Unmarshal(body, &updates)
	if err != nil {
		fmt.Printf("Failed to parse response: %v\n", err)
		return
	}

	if len(updates) == 0 {
		fmt.Println("No updates found.")
		return
	}

	latest := updates[0].Version

	prevVersion := ""
	if data, err := os.ReadFile(stateFilePath); err == nil {
		prevVersion = strings.TrimSpace(string(data))
	}

	if prevVersion == "" {
		fmt.Println("No previous version found. Storing latest:", latest)
		_ = os.WriteFile(stateFilePath, []byte(latest), 0644)
		prevVersion = latest
	}

	if versionCompare(latest, prevVersion) > 0 {
		fmt.Printf("New version found! %s > %s\n", latest, prevVersion)

		fmt.Println("Running update command...")
		cmd := exec.Command("./steamcmd.sh", "+runscript", "reforger_update")
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		err := cmd.Run()
		if err != nil {
			fmt.Printf("Update command failed: %v\n", err)
			return
		}

		_ = os.WriteFile(stateFilePath, []byte(latest), 0644)
		prevVersion = latest
	} else {
		fmt.Printf("No new version. Latest seen: %s\n", prevVersion)
	}

	// Always check and print players online
	client, err := a2s.New("192.168.1.5", 17777) // Adjust IP/port if needed
	if err != nil {
		fmt.Printf("Failed to create A2S client: %v\n", err)
		return
	}
	defer client.Close()

	players, err := client.GetPlayers()
	if err != nil {
		fmt.Printf("Failed to get players: %v\n", err)
		return
	}

    	if players == nil || len(*players) == 0 {
        	fmt.Println("No players online.")
    	} else {
        	maxIndex := byte(0)
        	for _, p := range *players {
            		if p.Index > maxIndex {
               			maxIndex = p.Index
            		}
        	}
        	fmt.Printf("Highest player index: %d\n", maxIndex)
    	}
}

func versionCompare(a, b string) int {
	segA := strings.Split(a, ".")
	segB := strings.Split(b, ".")

	max := len(segA)
	if len(segB) > max {
		max = len(segB)
	}

	for i := 0; i < max; i++ {
		var ai, bi int
		if i < len(segA) {
			fmt.Sscanf(segA[i], "%d", &ai)
		}
		if i < len(segB) {
			fmt.Sscanf(segB[i], "%d", &bi)
		}

		if ai > bi {
			return 1
		}
		if ai < bi {
			return -1
		}
	}
	return 0
}