package controller

import (
    "net/http"
    "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 DeviceDetailsController struct {
    deviceDetailsUC usecase.DeviceDetailsUseCase
    rg              *gin.RouterGroup
}

func NewDeviceDetailsController(deviceDetailsUC usecase.DeviceDetailsUseCase, rg *gin.RouterGroup) *DeviceDetailsController {
    return &DeviceDetailsController{
        deviceDetailsUC: deviceDetailsUC,
        rg:              rg,
    }
}

func (c *DeviceDetailsController) Route() {
    deviceDetails := c.rg.Group("/device-details")
    deviceDetails.Use(middleware.RequireAnyRole("Teknisi", "Admin", "Superadmin"))
    {
        deviceDetails.GET("", c.getAllDeviceDetails)
        deviceDetails.POST("", c.createDeviceDetails)
        deviceDetails.GET("/:id", c.getDeviceDetailsByID)
        deviceDetails.PUT("/:id", c.updateDeviceDetails)
        deviceDetails.DELETE("/:id", c.deleteDeviceDetails)
        deviceDetails.POST("/:id/recalculate-ports", c.recalculatePortUsage)
        deviceDetails.POST("/:id/assign-customer", c.assignCustomer)
        deviceDetails.PUT("/:id/port-usage", c.updatePortUsage) // New endpoint
        deviceDetails.PUT("/:id/port-assignments", c.updatePortAssignments) // New endpoint
    }
}

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

    var request struct {
        CustomerName string `json:"customer_name"`
        PortNumber   *int   `json:"port_number"`
    }
    
    if err := ctx.ShouldBindJSON(&request); err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    err = c.deviceDetailsUC.AssignCustomerToPort(deviceID, request.CustomerName, request.PortNumber)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    common.SingleResponses(ctx, "Customer assigned successfully", nil)
}


func (c *DeviceDetailsController) getAllDeviceDetails(ctx *gin.Context) {
    devices, err := c.deviceDetailsUC.GetAllDeviceDetails()
    if err != nil {
        common.ErrorResponses(ctx, http.StatusInternalServerError, err.Error())
        return
    }

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

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

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

    common.SingleResponses(ctx, "Device details created successfully", nil)
}

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

    device, err := c.deviceDetailsUC.GetDeviceDetailsByID(deviceID)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusNotFound, err.Error())
        return
    }

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

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

    var request req.UpdateDeviceDetailsDTO
    if err := ctx.ShouldBindJSON(&request); err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    err = c.deviceDetailsUC.UpdateDeviceDetails(deviceID, request)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    common.SingleResponses(ctx, "Device details updated successfully", nil)
}

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

    err = c.deviceDetailsUC.DeleteDeviceDetails(deviceID)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    common.SingleResponses(ctx, "Device details deleted successfully", nil)
}

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

    err = c.deviceDetailsUC.RecalculatePortUsage(deviceID)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusInternalServerError, err.Error())
        return
    }

    common.SingleResponses(ctx, "Port usage recalculated successfully", nil)
}

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

    var request req.UpdatePortUsageDTO
    if err := ctx.ShouldBindJSON(&request); err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    err = c.deviceDetailsUC.UpdatePortUsage(deviceID, request.PortUsed)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    common.SingleResponses(ctx, "Port usage updated successfully", nil)
}

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

    var request req.UpdatePortAssignmentsDTO
    if err := ctx.ShouldBindJSON(&request); err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    err = c.deviceDetailsUC.UpdatePortAssignments(deviceID, request.PortAssignments)
    if err != nil {
        common.ErrorResponses(ctx, http.StatusBadRequest, err.Error())
        return
    }

    common.SingleResponses(ctx, "Port assignments updated successfully", nil)
}