package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"path"
	"strconv"
	"strings"

	"hakurei.app/internal/rosa"
)

func serveCount(index *PackageIndex) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
		count := len(index.names)
		w.Write([]byte(strconv.Itoa(count)))
	}
}

func serveStatus(index *PackageIndex) func(w http.ResponseWriter, r *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		if index == nil {
			http.Error(w, "index is nil", http.StatusInternalServerError)
			return
		}
		base := path.Base(r.URL.Path)
		name := strings.TrimSuffix(base, ".log")
		p, ok := rosa.ResolveName(name)
		if !ok {
			http.NotFound(w, r)
			return
		}
		m := rosa.GetMetadata(p)
		pk, ok := index.names[m.Name]
		if !ok {
			http.NotFound(w, r)
			return
		}
		if len(pk.status) > 0 {
			w.Header().Set("Content-Type", "text/plain; charset=utf-8")
			w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
			w.WriteHeader(http.StatusOK)
			_, err := io.Copy(w, bytes.NewReader(pk.status))
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
			}
		} else {
			http.NotFound(w, r)
		}
	}
}

type GetPayload struct {
	Count  int                 `json:"count"`
	Values []PackageIndexEntry `json:"values"`
}

func NewGetPayload(values []*PackageIndexEntry) GetPayload {
	count := len(values)
	v := make([]PackageIndexEntry, count)
	for i, _ := range values {
		v[i] = *values[i]
	}
	return GetPayload{
		Count:  count,
		Values: v,
	}
}

func serveGet(index *PackageIndex) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		q := r.URL.Query()
		limit, err := strconv.Atoi(q.Get("limit"))
		if err != nil || limit > 100 || limit < 1 {
			http.Error(w, fmt.Sprintf("limit must be an integer between 1 and 100"), http.StatusBadRequest)
			return
		}
		i, err := strconv.Atoi(q.Get("index"))
		if err != nil || i >= len(index.sorts[0]) || i < 0 {
			http.Error(w, fmt.Sprintf("index must be an integer between 0 and %d", len(index.sorts[0])-1), http.StatusBadRequest)
			return
		}
		sort, err := strconv.Atoi(q.Get("sort"))
		if err != nil || sort >= len(index.sorts) || sort < 0 {
			http.Error(w, fmt.Sprintf("sort must be an integer between 0 and %d", len(index.sorts)-1), http.StatusBadRequest)
			return
		}
		values := index.sorts[sort][i:min(i+limit, len(index.sorts[sort]))]
		payload := NewGetPayload(values)
		w.Header().Set("Content-Type", "application/json; charset=utf-8")
		w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
		w.WriteHeader(http.StatusOK)
		b, err := json.Marshal(payload)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
		_, err = bytes.NewBuffer(b).WriteTo(w)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	}
}
func apiRoutes(index *PackageIndex) {
	http.HandleFunc("GET /api/count", serveCount(index))
	http.HandleFunc("GET /api/get", serveGet(index))
	http.HandleFunc("GET /api/status/", serveStatus(index))
}