package server

import (
	"bytes"
	"log/slog"
	"net/http"

	"git.lastassault.de/speatzle/morffix/constants"
	"git.lastassault.de/speatzle/morffix/types"
)

type IndexData struct {
	Counter []int

	Workers []IndexWorker
}

type IndexWorker struct {
	Worker
	Status *types.WorkerStatus
}

var count = 123456789

func handleIndex(w http.ResponseWriter, r *http.Request) {

	data := IndexData{
		Counter: splitInt(count),
		Workers: []IndexWorker{},
	}
	count++
	func() {
		WorkersMutex.Lock()
		defer WorkersMutex.Unlock()
		for i := range Workers {
			if Workers[i].Connected {
				var status types.WorkerStatus
				_, err := rpcServer.Call(r.Context(), Workers[i].Conn, "status", nil, &status)
				if err != nil {
					w.Write([]byte(err.Error()))
					slog.ErrorContext(r.Context(), "Error Getting Worker Status", "err", err)
					return
				}
				slog.InfoContext(r.Context(), "Got Worker Status", "id", i, "status", status)
				data.Workers = append(data.Workers, IndexWorker{
					Worker: *Workers[i],
					Status: &status,
				})
			} else {
				data.Workers = append(data.Workers, IndexWorker{
					Worker: *Workers[i],
					Status: nil,
				})
			}
		}
	}()
	buf := bytes.Buffer{}
	err := templates.ExecuteTemplate(&buf, constants.INDEX_TEMPLATE_NAME, data)
	if err != nil {
		slog.ErrorContext(r.Context(), "Executing index Template", "err", err)
		http.Error(w, "Error Executing Template: "+err.Error(), http.StatusInternalServerError)
		return
	}

	_, err = w.Write(buf.Bytes())
	if err != nil {
		slog.ErrorContext(r.Context(), "Writing http Response", "err", err)
	}
}

func splitInt(n int) []int {
	slc := []int{}
	for n > 0 {
		slc = append(slc, n%10)
		n /= 10
	}

	result := []int{}
	for i := range slc {
		result = append(result, slc[len(slc)-1-i])
	}

	return result
}