package handler

import (
	"net/http"

	"github.com/gin-gonic/gin"
	"kefu-sys/server/internal/middleware"
	"kefu-sys/server/internal/model"
)

type AdminHandler struct{}

func NewAdminHandler() *AdminHandler { return &AdminHandler{} }

func (h *AdminHandler) Stats(c *gin.Context) {
	var tenantTotal, activeTotal, monthlyIncome int64

	model.DB.Model(&model.Tenant{}).Count(&tenantTotal)
	model.DB.Model(&model.Tenant{}).Where("status = ?", "normal").Count(&activeTotal)

	middleware.JSON(c, gin.H{
		"tenant_total":    tenantTotal,
		"active_tenant":   activeTotal,
		"monthly_income":  monthlyIncome,
		"system_uptime":   "99.95%",
	})
}

func (h *AdminHandler) ListTenants(c *gin.Context) {
	page, pageSize := middleware.GetPageParams(c)
	search := c.Query("search")
	status := c.Query("status")
	plan := c.Query("plan")

	var tenants []model.Tenant
	var total int64

	query := model.DB.Model(&model.Tenant{})
	if search != "" {
		query = query.Where("name LIKE ? OR contact_name LIKE ?", "%"+search+"%", "%"+search+"%")
	}
	if status != "" {
		query = query.Where("status = ?", status)
	}
	if plan != "" {
		query = query.Where("plan_id IN (SELECT id FROM plans WHERE name = ?)", plan)
	}

	query.Count(&total)
	query.Order("created_at desc").Offset((page - 1) * pageSize).Limit(pageSize).Find(&tenants)

	middleware.JSONList(c, tenants, total, page, pageSize)
}

func (h *AdminHandler) GetTenant(c *gin.Context) {
	id := c.Param("id")
	var tenant model.Tenant
	if err := model.DB.First(&tenant, id).Error; err != nil {
		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "租户不存在"})
		return
	}
	middleware.JSON(c, tenant)
}

func (h *AdminHandler) CreateTenant(c *gin.Context) {
	var tenant model.Tenant
	if err := c.ShouldBindJSON(&tenant); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
		return
	}

	if err := model.DB.Create(&tenant).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "创建失败"})
		return
	}

	model.DB.Create(&model.OperationLog{
		OperatorID: middleware.GetUserID(c),
		Action:     "create_tenant",
		Detail:     "开通新租户: " + tenant.Name,
	})

	middleware.JSON(c, tenant)
}

func (h *AdminHandler) UpdateTenant(c *gin.Context) {
	id := c.Param("id")
	var tenant model.Tenant
	if err := model.DB.First(&tenant, id).Error; err != nil {
		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "租户不存在"})
		return
	}

	var updates map[string]interface{}
	if err := c.ShouldBindJSON(&updates); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
		return
	}

	delete(updates, "id")
	model.DB.Model(&tenant).Updates(updates)
	middleware.JSON(c, tenant)
}

func (h *AdminHandler) SuspendTenant(c *gin.Context) {
	id := c.Param("id")
	result := model.DB.Model(&model.Tenant{}).Where("id = ?", id).Update("status", "suspended")
	if result.RowsAffected == 0 {
		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "租户不存在"})
		return
	}

	model.DB.Create(&model.OperationLog{
		OperatorID: middleware.GetUserID(c),
		Action:     "suspend_tenant",
		Detail:     "暂停租户 ID:" + id,
	})

	middleware.JSON(c, gin.H{"message": "已暂停"})
}

func (h *AdminHandler) ResumeTenant(c *gin.Context) {
	id := c.Param("id")
	result := model.DB.Model(&model.Tenant{}).Where("id = ?", id).Update("status", "normal")
	if result.RowsAffected == 0 {
		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "租户不存在"})
		return
	}

	middleware.JSON(c, gin.H{"message": "已恢复"})
}

func (h *AdminHandler) ListPlans(c *gin.Context) {
	var plans []model.Plan
	model.DB.Find(&plans)
	middleware.JSON(c, plans)
}

func (h *AdminHandler) CreatePlan(c *gin.Context) {
	var plan model.Plan
	if err := c.ShouldBindJSON(&plan); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
		return
	}

	model.DB.Create(&plan)
	middleware.JSON(c, plan)
}

func (h *AdminHandler) UpdatePlan(c *gin.Context) {
	id := c.Param("id")
	var plan model.Plan
	if err := model.DB.First(&plan, id).Error; err != nil {
		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "套餐不存在"})
		return
	}

	var updates map[string]interface{}
	if err := c.ShouldBindJSON(&updates); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
		return
	}

	delete(updates, "id")
	model.DB.Model(&plan).Updates(updates)
	middleware.JSON(c, plan)
}

func (h *AdminHandler) ListLogs(c *gin.Context) {
	page, pageSize := middleware.GetPageParams(c)

	var logs []model.OperationLog
	var total int64

	model.DB.Model(&model.OperationLog{}).Count(&total)
	model.DB.Order("created_at desc").Offset((page - 1) * pageSize).Limit(pageSize).Find(&logs)

	middleware.JSONList(c, logs, total, page, pageSize)
}

func (h *AdminHandler) ListAnnouncements(c *gin.Context) {
	var announcements []model.Announcement
	model.DB.Order("created_at desc").Find(&announcements)
	middleware.JSON(c, announcements)
}

func (h *AdminHandler) CreateAnnouncement(c *gin.Context) {
	var ann model.Announcement
	if err := c.ShouldBindJSON(&ann); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
		return
	}

	model.DB.Create(&ann)
	middleware.JSON(c, ann)
}

func (h *AdminHandler) UpdateAnnouncement(c *gin.Context) {
	id := c.Param("id")
	var ann model.Announcement
	if err := model.DB.First(&ann, id).Error; err != nil {
		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "公告不存在"})
		return
	}

	var updates map[string]interface{}
	if err := c.ShouldBindJSON(&updates); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
		return
	}

	delete(updates, "id")
	model.DB.Model(&ann).Updates(updates)
	middleware.JSON(c, ann)
}

func (h *AdminHandler) DeleteAnnouncement(c *gin.Context) {
	id := c.Param("id")
	model.DB.Delete(&model.Announcement{}, id)
	middleware.JSON(c, gin.H{"message": "已删除"})
}