// Package handler provides HTTP handlers for various endpoints.
package handler

import (
	"fmt"
	"net/http"

	"modelRT/logger"
	"modelRT/model"
	"modelRT/network"

	"github.com/gin-gonic/gin"
)

// MeasurementRecommendHandler define measurement recommend API
func MeasurementRecommendHandler(c *gin.Context) {
	var request network.MeasurementRecommendRequest

	if err := c.ShouldBindJSON(&request); err != nil {
		logger.Error(c, "failed to unmarshal measurement recommend request", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  err.Error(),
		})
		return
	}

	recommends, isFuzzy, err := model.RedisSearchRecommend(c, request.Input)
	// TODO delete debug info
	fmt.Printf("recommends in handler:%+v\n", recommends)
	if err != nil {
		logger.Error(c, "failed to get recommend data from redis", "input", request.Input, "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  err.Error(),
			PayLoad: map[string]any{
				"input": request.Input,
			},
		})
		return
	}

	fmt.Printf("isFuzzy:%v\n", isFuzzy)

	var finalOffset int
	if isFuzzy {
		var maxOffset int
		for index, recommend := range recommends {
			offset := model.GetLongestCommonPrefixLength(request.Input, recommend)
			if index == 0 || offset > maxOffset {
				maxOffset = offset
			}
		}
		finalOffset = maxOffset
	} else {
		var minOffset int
		for index, recommend := range recommends {
			offset := model.GetLongestCommonPrefixLength(request.Input, recommend)
			if index == 0 || offset < minOffset {
				minOffset = offset
			}
		}
		finalOffset = minOffset
	}

	fmt.Printf("finalOffset:%v\n", finalOffset)

	resultRecommends := make([]string, 0, len(recommends))
	seen := make(map[string]struct{})

	for _, recommend := range recommends {
		recommendTerm := recommend[finalOffset:]
		fmt.Printf("resultRecommend:%s\n", recommendTerm)
		fmt.Printf("len of resultRecommend:%d\n", len(recommendTerm))
		if len(recommendTerm) != 0 {
			if _, exists := seen[recommendTerm]; !exists {
				seen[recommendTerm] = struct{}{}
				resultRecommends = append(resultRecommends, recommendTerm)
			}
		}
	}

	c.JSON(http.StatusOK, network.SuccessResponse{
		Code: http.StatusOK,
		Msg:  "success",
		PayLoad: map[string]any{
			"input":            request.Input,
			"offset":           finalOffset,
			"recommended_list": resultRecommends,
		},
	})
}