package controller

import (
    "net/http"
    "strconv"
    "users_management/m/middleware"
    "users_management/m/model/dto/req"
    "users_management/m/usecase"
    "users_management/m/utils/common"

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

type NearestDeviceController struct {
    nearestDeviceUC usecase.NearestDeviceUseCase
    rg              *gin.RouterGroup
}

func NewNearestDeviceController(nearestDeviceUC usecase.NearestDeviceUseCase, rg *gin.RouterGroup) *NearestDeviceController {
    return &NearestDeviceController{
        nearestDeviceUC: nearestDeviceUC,
        rg:              rg,
    }
}

func (c *NearestDeviceController) Route() {
    nearestDevices := c.rg.Group("/nearest-devices")
    nearestDevices.Use(middleware.RequireAnyRole("Teknisi", "Admin", "Superadmin"))
    {
        nearestDevices.POST("/search", c.getNearestDevices)
        nearestDevices.GET("/:id", c.getNearestDeviceByID)
    }
}

func (c *NearestDeviceController) getNearestDevices(ctx *gin.Context) {
    var request req.NearestDeviceDTO
    if err := ctx.ShouldBindJSON(&request); err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    devices, err := c.nearestDeviceUC.GetNearestDevices(request)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    response := gin.H{
        "devices": devices,
        "total":   len(devices),
        "search_params": gin.H{
            "latitude":  request.Latitude,
            "longitude": request.Longitude,
            "radius":    request.Radius,
            "province":  request.Province,
            "city":      request.City,
            "district":  request.District,
        },
    }

    common.SingleResponses(ctx, "Nearest devices retrieved successfully", response)
}

func (c *NearestDeviceController) getNearestDeviceByID(ctx *gin.Context) {
    id := ctx.Param("id")
    deviceID, err := uuid.Parse(id)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, "Invalid device ID")
        return
    }

    // Get user coordinates from query params
    latStr := ctx.Query("lat")
    lngStr := ctx.Query("lng")
    
    if latStr == "" || lngStr == "" {
        common.ErrorResponses(ctx, http.StatusBadRequest, "User coordinates (lat, lng) are required")
        return
    }

    userLat, err := strconv.ParseFloat(latStr, 64)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, "Invalid latitude")
        return
    }

    userLng, err := strconv.ParseFloat(lngStr, 64)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, "Invalid longitude")
        return
    }

    device, err := c.nearestDeviceUC.GetNearestDeviceByID(deviceID, userLat, userLng)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusNotFound, err.Error())
        return
    }

    common.SingleResponses(ctx, "Device details retrieved successfully", device)
}