package controller

import (
	"encoding/json"
	"fmt"
	"io"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"hy2xs-admin/model/bo"
	"hy2xs-admin/model/constant"
	"hy2xs-admin/model/dto"
	"hy2xs-admin/model/vo"
	"hy2xs-admin/service"
	"hy2xs-admin/util"
)

func resolveID(c *gin.Context) (int64, error) {
	if raw := strings.TrimSpace(c.Param("id")); raw != "" {
		parsed, err := strconv.ParseInt(raw, 10, 64)
		if err == nil && parsed > 0 {
			return parsed, nil
		}
	}
	idDto, err := validateField(c, dto.IdDto{})
	if err != nil {
		return 0, err
	}
	return *idDto.Id, nil
}

func Login(c *gin.Context) {
	loginDto, err := validateField(c, dto.LoginDto{})
	if err != nil {
		return
	}
	token, forcePasswordChange, err := service.Login(*loginDto.Username, *loginDto.Pass)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(vo.JwtVo{TokenType: constant.TokenType, AccessToken: token, ForcePasswordChange: forcePasswordChange}, c)
}

func PagePeer(c *gin.Context) {
	peerPageDto, err := validateField(c, dto.PeerPageDto{})
	if err != nil {
		return
	}
	records, total, err := service.PagePeer(peerPageDto)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(vo.PeerPageVo{Records: records, Total: total}, c)
}

func SavePeer(c *gin.Context) {
	peerSaveDto, err := validateField(c, dto.PeerSaveDto{})
	if err != nil {
		return
	}
	peerVo, err := service.CreatePeer(peerSaveDto)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(peerVo, c)
}

func DeletePeer(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	if err = service.DeletePeer(id); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func UpdatePeer(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	peerUpdateDto, err := validateField(c, dto.PeerUpdateDto{})
	if err != nil {
		return
	}
	if peerUpdateDto.Name != nil && *peerUpdateDto.Name != "" && service.ExistPeerName(*peerUpdateDto.Name, id) {
		vo.Fail(fmt.Sprintf("name %s already exists", *peerUpdateDto.Name), c)
		return
	}
	if err = service.UpdatePeer(id, peerUpdateDto); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func ResetTraffic(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	if err = service.ResetPeerTraffic(id); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func GetPeer(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	peer, err := service.GetPeerVo(id)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(peer, c)
}

func ImportPeer(c *gin.Context) {
	file, header, err := c.Request.FormFile("file")
	if err != nil {
		vo.Fail(constant.SysError, c)
		return
	}
	if header.Size > 1024*1024*2 {
		vo.Fail("the file is too big", c)
		return
	}
	if !strings.HasSuffix(header.Filename, ".json") {
		vo.Fail(constant.InvalidError, c)
		return
	}
	content, err := io.ReadAll(file)
	if err != nil {
		vo.Fail("json file read err", c)
		return
	}
	var peerExports []bo.PeerExport
	if err = json.Unmarshal(content, &peerExports); err != nil {
		vo.Fail("content Unmarshal err", c)
		return
	}
	if err = service.UpsertPeerExport(peerExports); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func ExportPeer(c *gin.Context) {
	includeSecrets := strings.EqualFold(strings.TrimSpace(c.Query("includeSecrets")), "true")
	peerExports, err := service.ListExportPeer(includeSecrets)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	fileName := fmt.Sprintf("PeerExport-%s.json", time.Now().Format("20060102150405"))
	filePath := filepath.Join(constant.ExportPathDir, fileName)
	if err = util.ExportFile(filePath, peerExports, 0); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	if !util.Exists(filePath) {
		vo.Fail("file not exist", c)
		return
	}
	c.Header("Content-Type", "application/octet-stream")
	c.Header("Content-Transfer-Encoding", "binary")
	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", fileName))
	c.File(filePath)
}

func ReleaseKickPeer(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	if err = service.ReleaseKickPeer(id); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func KickPeer(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	kickDto, err := validateField(c, dto.PeerKickDto{})
	if err != nil {
		return
	}
	if err = service.KickPeer(id, *kickDto.BannedUntil); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func PeerClientConfig(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	data, err := service.BuildPeerClientConfig(id)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(data, c)
}