package controllers

import (
	"lokistack/dto"
	"lokistack/models"
	"lokistack/pkg/crypto"
	"lokistack/services"
	"lokistack/utils"

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

type StorageController struct {
	service *services.StorageService
}

func NewStorageController() *StorageController {
	return &StorageController{service: services.NewStorageService()}
}

func (ctrl *StorageController) Create(c *gin.Context) {
	var req dto.CreateStorageRequest
	if !utils.BindAndValidate(c, &req) {
		return
	}
	storage, err := ctrl.service.Create(req.Name, req.StorageType, req.Endpoint, req.Bucket,
		req.Region, req.AccessKey, req.SecretKey, req.PathPrefix, req.Insecure, req.IsDefault)
	if err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, models.SanitizedJSON(storage))
}

func (ctrl *StorageController) Get(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	storage, err := ctrl.service.Get(uint(id))
	if err != nil {
		utils.NotFound(c, "存储配置不存在")
		return
	}
	utils.Success(c, models.SanitizedJSON(storage))
}

func (ctrl *StorageController) List(c *gin.Context) {
	page, pageSize := utils.Pagination(c)
	storages, total, err := ctrl.service.List(page, pageSize)
	if err != nil {
		utils.Error(c, 500, err.Error())
		return
	}
	utils.Success(c, utils.PageData{
		List:  models.SanitizedJSON(storages),
		Total: total, Page: page, PageSize: pageSize,
	})
}

func (ctrl *StorageController) Update(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	var updates map[string]interface{}
	if !utils.BindAndValidate(c, &updates) {
		return
	}
	if err := ctrl.service.Update(uint(id), updates); err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, gin.H{"message": "updated"})
}

func (ctrl *StorageController) Delete(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	if err := ctrl.service.Delete(uint(id)); err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, gin.H{"message": "deleted"})
}

func (ctrl *StorageController) GetDefault(c *gin.Context) {
	storage, err := ctrl.service.GetDefault()
	if err != nil {
		utils.NotFound(c, "未设置默认存储配置")
		return
	}
	utils.Success(c, models.SanitizedJSON(storage))
}

// TestConnection 测试对象存储连接(凭证 + 桶存在性,可选自动创建;不落库)
func (ctrl *StorageController) TestConnection(c *gin.Context) {
	var req dto.StorageTestRequest
	if !utils.BindAndValidate(c, &req) {
		return
	}
	accessKey, secretKey := req.AccessKey, req.SecretKey
	// SecretKey 出于安全不返回给前端；编辑态测试时前端留空，
	// 这里用库里保存的凭据补齐（AccessKey 同理，前端通常会带上，但不强制）。
	if (accessKey == "" || secretKey == "") && req.ID > 0 {
		if cfg, err := ctrl.service.Get(req.ID); err == nil {
			if accessKey == "" {
				accessKey = crypto.DecryptField(cfg.AccessKey)
			}
			if secretKey == "" {
				secretKey = crypto.DecryptField(cfg.SecretKey)
			}
		}
	}
	if accessKey == "" || secretKey == "" {
		utils.BadRequest(c, "缺少 Access Key / Secret Key：新建存储时必须填写")
		return
	}

	result := services.TestStorageConnection(services.StorageTestParams{
		StorageType:     req.StorageType,
		Endpoint:        req.Endpoint,
		Bucket:          req.Bucket,
		Region:          req.Region,
		AccessKey:       accessKey,
		SecretKey:       secretKey,
		Insecure:        req.Insecure,
		CreateIfMissing: req.CreateIfMissing,
	})
	utils.Success(c, result)
}