package controller

import (
	"net/http"
	"strings"
	"unicode/utf8"

	"github.com/QuantumNous/new-api/common"
	"github.com/QuantumNous/new-api/model"
	"github.com/QuantumNous/new-api/service"
	"github.com/gin-gonic/gin"
)

func GetStatusPageAdmin(c *gin.Context) {
	results, err := currentGroupMonitors(c.Request.Context(), true)
	if err != nil {
		common.ApiError(c, err)
		return
	}
	c.JSON(http.StatusOK, gin.H{"success": true, "data": results})
}

func UpdateStatusPageGroup(c *gin.Context) {
	var input struct {
		Group  string `json:"group"`
		Alias  string `json:"alias"`
		Hidden *bool  `json:"hidden"`
	}
	if c.ShouldBindJSON(&input) != nil || strings.TrimSpace(input.Group) == "" || utf8.RuneCountInString(input.Group) > 64 {
		c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "Invalid group"})
		return
	}
	reset := strings.HasSuffix(c.FullPath(), "/reset")
	input.Alias = strings.TrimSpace(input.Alias)
	if !reset && (input.Hidden == nil || utf8.RuneCountInString(input.Alias) > 80 || strings.ContainsAny(input.Alias, "\r\n\t")) {
		c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "Invalid display settings"})
		return
	}
	channels, err := model.GetStatusChannels(c.Request.Context())
	if err != nil {
		common.ApiError(c, err)
		return
	}
	found := false
	for _, channel := range channels {
		for group := range strings.SplitSeq(channel.Group, ",") {
			if strings.TrimSpace(group) == input.Group {
				found = true
			}
		}
	}
	if !found {
		c.JSON(http.StatusNotFound, gin.H{"success": false, "message": "Group not found"})
		return
	}
	var display *model.StatusPageGroup
	if !reset {
		display = &model.StatusPageGroup{Alias: input.Alias, Hidden: *input.Hidden}
	}
	if err := model.SaveStatusPageGroup(c.Request.Context(), input.Group, display); err != nil {
		common.ApiError(c, err)
		return
	}
	service.InvalidateGroupQualityCache()
	publishGroupStatusChange()
	c.JSON(http.StatusOK, gin.H{"success": true})
}

// Main-site group status is independent of the public uptime display settings.
func GetSiteGroupStatus(c *gin.Context) {
	results, err := currentGroupMonitors(c.Request.Context(), true)
	if err != nil {
		common.ApiError(c, err)
		return
	}
	costs, costErr := service.GroupModelCosts(c.Request.Context())
	if costErr != nil {
		common.SysError("group model costs: " + costErr.Error())
	}
	metadata, err := model.GetGroupMetadata(c.Request.Context())
	if err != nil {
		common.ApiError(c, err)
		return
	}
	recent, err := service.RecentDegradedGroups(c.Request.Context())
	if err != nil {
		common.ApiError(c, err)
		return
	}
	for i := range results {
		monitors := make([]Monitor, 0, len(results[i].Monitors))
		for _, monitor := range results[i].Monitors {
			if monitor.Group == "luna" || monitor.Group == "gpt-images" {
				continue
			}
			monitor.Tags = metadata[monitor.Group].Tags
			monitor.RecentDegraded = recent[monitor.Group] && !metadata[monitor.Group].HideRecentDegraded
			monitor.Name = monitor.Group
			monitor.Alias = ""
			monitor.Hidden = false
			monitor.ModelCosts = map[string]model.GroupModelCost{}
			for _, name := range monitor.Models {
				if value, ok := costs[monitor.Group][name]; ok {
					monitor.ModelCosts[name] = value
				}
			}
			monitors = append(monitors, monitor)
		}
		results[i].Monitors = monitors
	}
	c.JSON(http.StatusOK, gin.H{"success": true, "data": results})
}