package handler

import (
	"net/http"
	"videoplayer/proto"
	"videoplayer/service"

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

func SetDNSGroup(router *gin.Engine) {
	dns := router.Group("/dns")

	dns.POST("/server/create", CreateDNSServerHandler)
	dns.POST("/server/get", GetDNSServerHandler)
	dns.POST("/server/update", UpdateDNSServerHandler)
	dns.POST("/server/delete", DeleteDNSServerHandler)
	dns.POST("/server/start", StartDNSServerHandler)
	dns.POST("/server/stop", StopDNSServerHandler)
	dns.POST("/server/restart", RestartDNSServerHandler)
	dns.POST("/server/status", GetDNSServerStatusHandler)

	dns.POST("/zone/create", CreateDNSZoneHandler)
	dns.POST("/zone/get", GetDNSZoneHandler)
	dns.POST("/zone/update", UpdateDNSZoneHandler)
	dns.POST("/zone/delete", DeleteDNSZoneHandler)

	dns.POST("/record/create", CreateDNSRecordHandler)
	dns.POST("/record/get", GetDNSRecordHandler)
	dns.POST("/record/update", UpdateDNSRecordHandler)
	dns.POST("/record/delete", DeleteDNSRecordHandler)
}

// ==================== DNSServer 相关 Handler ====================

func CreateDNSServerHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := uint(id.(float64))

	var req proto.CreateDNSServerReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		server, err := service.CreateDNSServer(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "创建DNS服务器失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "创建DNS服务器成功"
			resp.Data = server
		}
	}
	c.JSON(http.StatusOK, resp)
}

func GetDNSServerHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := uint(id.(float64))

	var req proto.GetDNSServerReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		servers, err := service.GetDNSServerList(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "获取DNS服务器失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "获取DNS服务器成功"
			resp.Data = servers
		}
	}
	c.JSON(http.StatusOK, resp)
}

func UpdateDNSServerHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.UpdateDNSServerReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		server, err := service.UpdateDNSServer(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "更新DNS服务器失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "更新DNS服务器成功"
			resp.Data = server
		}
	}
	c.JSON(http.StatusOK, resp)
}

func DeleteDNSServerHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.DeleteDNSServerReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		err := service.DeleteDNSServer(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "删除DNS服务器失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "删除DNS服务器成功"
		}
	}
	c.JSON(http.StatusOK, resp)
}

// ==================== DNSZone 相关 Handler ====================

func CreateDNSZoneHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := uint(id.(float64))

	var req proto.CreateDNSZoneReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		zone, err := service.CreateDNSZone(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "创建DNS区域失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "创建DNS区域成功"
			resp.Data = zone
		}
	}
	c.JSON(http.StatusOK, resp)
}

func GetDNSZoneHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := uint(id.(float64))

	var req proto.GetDNSZoneReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		zones, err := service.GetDNSZoneList(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "获取DNS区域失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "获取DNS区域成功"
			resp.Data = zones
		}
	}
	c.JSON(http.StatusOK, resp)
}

func UpdateDNSZoneHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.UpdateDNSZoneReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		zone, err := service.UpdateDNSZone(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "更新DNS区域失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "更新DNS区域成功"
			resp.Data = zone
		}
	}
	c.JSON(http.StatusOK, resp)
}

func DeleteDNSZoneHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.DeleteDNSZoneReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		err := service.DeleteDNSZone(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "删除DNS区域失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "删除DNS区域成功"
		}
	}
	c.JSON(http.StatusOK, resp)
}

// ==================== DNSRecord 相关 Handler ====================

func CreateDNSRecordHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := uint(id.(float64))

	var req proto.CreateDNSRecordReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		record, err := service.CreateDNSRecord(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "创建DNS记录失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "创建DNS记录成功"
			resp.Data = record
		}
	}
	c.JSON(http.StatusOK, resp)
}

func GetDNSRecordHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := uint(id.(float64))

	var req proto.GetDNSRecordReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		records, err := service.GetDNSRecordList(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "获取DNS记录失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "获取DNS记录成功"
			resp.Data = records
		}
	}
	c.JSON(http.StatusOK, resp)
}

func UpdateDNSRecordHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.UpdateDNSRecordReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		record, err := service.UpdateDNSRecord(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "更新DNS记录失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "更新DNS记录成功"
			resp.Data = record
		}
	}
	c.JSON(http.StatusOK, resp)
}

func DeleteDNSRecordHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.DeleteDNSRecordReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		err := service.DeleteDNSRecord(&req, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "删除DNS记录失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "删除DNS记录成功"
		}
	}
	c.JSON(http.StatusOK, resp)
}

// 启动DNS服务器
func StartDNSServerHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.StartDNSServerReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		instance, err := service.StartDNSServer(req.ServerID, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "启动DNS服务器失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "启动DNS服务器成功"
			resp.Data = instance
		}
	}
	c.JSON(http.StatusOK, resp)
}

// 停止DNS服务器
func StopDNSServerHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.StopDNSServerReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		err := service.StopDNSServer(req.ServerID, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "停止DNS服务器失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "停止DNS服务器成功"
		}
	}
	c.JSON(http.StatusOK, resp)
}

// 重启DNS服务器
func RestartDNSServerHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.RestartDNSServerReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		instance, err := service.RestartDNSServer(req.ServerID, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "重启DNS服务器失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "重启DNS服务器成功"
			resp.Data = instance
		}
	}
	c.JSON(http.StatusOK, resp)
}

// 获取DNS服务器状态
func GetDNSServerStatusHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.GetDNSServerStatusReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		status, err := service.GetDNSServerStatus(req.ServerID, userID)
		if err != nil {
			resp.Code = proto.ErrorCode
			resp.Message = "获取DNS服务器状态失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "获取DNS服务器状态成功"
			resp.Data = status
		}
	}
	c.JSON(http.StatusOK, resp)
}