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 {
	ID string
	Worker
	Status        *types.WorkerStatus
	QueueEnable   bool
	ParallelTasks int
}

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

	data := IndexData{
		Workers: []IndexWorker{},
	}
	func() {
		WorkersMutex.Lock()
		defer WorkersMutex.Unlock()
		for i := range Workers {

			var queueEnable bool
			var parallelTasks int
			err := db.QueryRow(r.Context(), "SELECT queue_enable, parallel_tasks FROM workers WHERE id = $1", i).Scan(&queueEnable, &parallelTasks)
			if err != nil {
				w.Write([]byte(err.Error()))
				slog.ErrorContext(r.Context(), "Error Querying Worker", "err", err)
			}

			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{
					ID:            i,
					Worker:        *Workers[i],
					Status:        &status,
					QueueEnable:   queueEnable,
					ParallelTasks: parallelTasks,
				})
			} else {
				data.Workers = append(data.Workers, IndexWorker{
					ID:            i,
					Worker:        *Workers[i],
					Status:        nil,
					QueueEnable:   queueEnable,
					ParallelTasks: parallelTasks,
				})
			}
		}
	}()

	var size int
	err := db.QueryRow(r.Context(), "SELECT SUM(size) AS size FROM files WHERE status = $1", constants.FILE_STATUS_EXISTS).Scan(&size)
	if err != nil {
		size = 0
	}
	data.Counter = splitInt(size)

	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 {
	if n == 0 {
		return []int{0}
	}

	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
}