package controller

import (
	"fmt"
	"net/http"
	"strconv"
	"strings"

	"ezops/model"

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

// 批量操作域：批量导入 + 批量删除 // Logan.Li

// BatchCreateServers 批量导入服务器 // Logan.Li
// 接收 {servers:[...], region_id, auth_type, credential_id}，逐条校验并创建，跳过重复（主机名或IP已存在）
func (h *ServerHandler) BatchCreateServers(c *gin.Context) {
	var req model.BatchCreateServerRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.Response{
			Code:    400,
			Message: "请求参数错误: " + err.Error(),
		})
		return
	}

	authType := strings.TrimSpace(req.AuthType)
	if authType == "" {
		authType = "password"
	}

	// 如果指定了凭据，提前解密 // Logan.Li
	var decryptedPwd, decryptedKey string
	if req.CredentialID != nil && *req.CredentialID > 0 {
		var cred model.Credential
		if err := h.db.First(&cred, *req.CredentialID).Error; err != nil {
			c.JSON(http.StatusBadRequest, model.Response{Code: 400, Message: "凭据不存在"})
			return
		}
		plain, err := h.crypt.Decrypt(cred.Content)
		if err != nil {
			c.JSON(http.StatusInternalServerError, model.Response{Code: 500, Message: "凭据解密失败"})
			return
		}
		if cred.SecretType == "ssh" {
			decryptedKey = plain
			authType = "key"
		} else {
			decryptedPwd = plain
			authType = "password"
		}
	}

	result := model.BatchCreateResult{Errors: []string{}}
	for i, item := range req.Servers {
		hostname := strings.TrimSpace(item.Hostname)
		ip := strings.TrimSpace(item.IP)
		if hostname == "" || ip == "" {
			result.Failed++
			result.Errors = append(result.Errors, fmt.Sprintf("第%d行: 主机名和IP不能为空", i+2))
			continue
		}

		// 重复检查（主机名或 IP 已存在则跳过）
		var count int64
		h.db.Model(&model.Server{}).Where("hostname = ? OR ip = ?", hostname, ip).Count(&count)
		if count > 0 {
			result.Skipped++
			continue
		}

		port := item.Port
		if port == 0 {
			port = 22
		}
		username := strings.TrimSpace(item.Username)
		if username == "" {
			username = "root"
		}

		server := model.Server{
			Hostname: hostname,
			IP:       ip,
			Port:     port,
			Username: username,
			AuthType: authType,
			Password: decryptedPwd,
			SSHKey:   decryptedKey,
			OS:       item.OS,
			CPU:      item.CPU,
			Memory:   item.Memory * 1024, // GB → MB
			Disk:     item.Disk,
			Tags:     item.Tags,
			RegionID: req.RegionID,
			Status:   "stopped",
		}
		if err := h.db.Create(&server).Error; err != nil {
			result.Failed++
			result.Errors = append(result.Errors, fmt.Sprintf("%s(%s): %s", hostname, ip, err.Error()))
			continue
		}
		result.Success++
	}

	msg := fmt.Sprintf("导入完成: 成功 %d, 跳过 %d, 失败 %d", result.Success, result.Skipped, result.Failed)
	c.JSON(http.StatusOK, model.Response{
		Code:    200,
		Message: msg,
		Data:    result,
	})
}

// BatchDeleteServers 批量删除服务器 // Logan.Li
// @Summary 批量删除服务器
// @Description 批量删除服务器
// @Tags 服务器
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body model.IDsRequest true "删除请求"
// @Success 200 {object} model.Response
// @Router /servers/batch-delete [post]
func (h *ServerHandler) BatchDeleteServers(c *gin.Context) {
	var req model.IDsRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.Response{
			Code:    400,
			Message: "请求参数错误",
		})
		return
	}

	// 查询待删除服务器用于审计日志 // Logan.Li
	var servers []model.Server
	h.db.Where("id IN ?", req.IDs).Find(&servers)

	// 硬删除：先清理每台服务器的 Agent 上报和聚合数据
	for _, s := range servers {
		h.db.Unscoped().Where("hostname = ?", s.Hostname).Delete(&model.AgentReport{})
		h.db.Unscoped().Where("hostname = ?", s.Hostname).Delete(&model.MetricsAggregate{})
	}

	if err := h.db.Unscoped().Delete(&model.Server{}, req.IDs).Error; err != nil {
		c.JSON(http.StatusInternalServerError, model.Response{
			Code:    500,
			Message: "删除失败",
		})
		return
	}

	// 记录批量删除审计日志
	for _, s := range servers {
		h.recordServerAudit(c, "delete", s.Hostname+" ("+s.IP+")", strconv.Itoa(int(s.ID)), 1, "")
	}

	c.JSON(http.StatusOK, model.Response{
		Code:    200,
		Message: "服务器已彻底删除",
	})
}