package handler

import (
	"time"

	"github.com/gin-gonic/gin"
	"github.com/muyuqingfeng/iloom/auth-service/internal/repository"
	"github.com/muyuqingfeng/iloom/shared/pkg/response"
)

type CommonHandler struct {
	shareLinkRepo *repository.ShareLinkRepo
	auditLogRepo  *repository.AuditLogRepo
}

func NewCommonHandler(slRepo *repository.ShareLinkRepo, alRepo *repository.AuditLogRepo) *CommonHandler {
	return &CommonHandler{shareLinkRepo: slRepo, auditLogRepo: alRepo}
}

type createShareLinkReq struct {
	ResourceType string `json:"resource_type" binding:"required"`
	ResourceID   string `json:"resource_id" binding:"required"`
	ExpiresIn    int    `json:"expires_in"` // seconds, 0 = no expiry
}

func (h *CommonHandler) CreateShareLink(c *gin.Context) {
	var req createShareLinkReq
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "invalid request: "+err.Error())
		return
	}

	userID := c.GetHeader("X-User-ID")
	companyID := c.GetHeader("X-Company-ID")

	var expiresAt *time.Time
	if req.ExpiresIn > 0 {
		t := time.Now().Add(time.Duration(req.ExpiresIn) * time.Second)
		expiresAt = &t
	}

	link, err := h.shareLinkRepo.Create(c.Request.Context(), companyID, userID, req.ResourceType, req.ResourceID, expiresAt)
	if err != nil {
		response.InternalError(c, err.Error())
		return
	}

	response.OK(c, link)
}

func (h *CommonHandler) GetShareLink(c *gin.Context) {
	code := c.Param("code")

	link, err := h.shareLinkRepo.GetByCode(c.Request.Context(), code)
	if err != nil {
		response.InternalError(c, err.Error())
		return
	}
	if link == nil {
		response.NotFound(c, "share link not found")
		return
	}

	// check expiry
	if link.ExpiresAt != nil && link.ExpiresAt.Before(time.Now()) {
		response.BadRequest(c, "share link expired")
		return
	}

	response.OK(c, link)
}

type feedbackReq struct {
	Content string `json:"content" binding:"required"`
	Type    string `json:"type"`
}

func (h *CommonHandler) Feedback(c *gin.Context) {
	var req feedbackReq
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "invalid request: "+err.Error())
		return
	}

	userID := c.GetHeader("X-User-ID")
	companyID := c.GetHeader("X-Company-ID")

	feedbackType := req.Type
	if feedbackType == "" {
		feedbackType = "general"
	}

	err := h.auditLogRepo.Create(
		c.Request.Context(), userID, companyID,
		"feedback", feedbackType, "",
		c.ClientIP(), map[string]string{"content": req.Content},
	)
	if err != nil {
		response.InternalError(c, err.Error())
		return
	}

	response.OK(c, gin.H{"message": "feedback received"})
}

type crashReportReq struct {
	Error      string `json:"error" binding:"required"`
	StackTrace string `json:"stack_trace"`
	UserAgent  string `json:"user_agent"`
	URL        string `json:"url"`
}

func (h *CommonHandler) CrashReport(c *gin.Context) {
	var req crashReportReq
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "invalid request: "+err.Error())
		return
	}

	userID := c.GetHeader("X-User-ID")
	companyID := c.GetHeader("X-Company-ID")

	err := h.auditLogRepo.Create(
		c.Request.Context(), userID, companyID,
		"crash_report", "frontend", "",
		c.ClientIP(), req,
	)
	if err != nil {
		response.InternalError(c, err.Error())
		return
	}

	response.OK(c, gin.H{"message": "crash report received"})
}