package controllers

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

	"server/models"
	"server/pkg/jwtutil"
	"server/services"

	"github.com/beego/beego/v2/client/orm"
	beego "github.com/beego/beego/v2/server/web"
)

type PlatformSoftwareUpgradeController struct {
	beego.Controller
}

func (c *PlatformSoftwareUpgradeController) platformClaims() (*jwtutil.Claims, error) {
	auth := c.Ctx.Request.Header.Get("Authorization")
	if auth == "" {
		return nil, fmt.Errorf("未登录")
	}
	parts := strings.SplitN(auth, " ", 2)
	if len(parts) != 2 || parts[0] != "Bearer" {
		return nil, fmt.Errorf("认证信息格式错误")
	}
	claims, err := jwtutil.ParseToken(parts[1])
	if err != nil {
		return nil, fmt.Errorf("无效的token")
	}
	if claims.UserType != "platform" {
		return nil, fmt.Errorf("无权访问")
	}
	return claims, nil
}

func (c *PlatformSoftwareUpgradeController) jsonErr(httpStatus, bizCode int, msg string) {
	c.Ctx.Output.SetStatus(httpStatus)
	c.Data["json"] = map[string]interface{}{"code": bizCode, "msg": msg}
	_ = c.ServeJSON()
}

func (c *PlatformSoftwareUpgradeController) ok(data interface{}) {
	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": data}
	_ = c.ServeJSON()
}

func (c *PlatformSoftwareUpgradeController) backfillDownloadURL(productID uint64) {
	var row models.SystemSoftwareUpgrade
	err := models.Orm.QueryTable(new(models.SystemSoftwareUpgrade)).
		Filter("id", productID).
		Filter("delete_time__isnull", true).
		One(&row)
	if err != nil {
		return
	}
	if row.FileID == nil || *row.FileID == 0 {
		return
	}
	if row.DownloadURL != nil && strings.TrimSpace(*row.DownloadURL) != "" {
		return
	}
	scheme, host := services.PublicRequestBaseURL(&c.Controller)
	u := services.ResolveSoftwareDownloadURL(scheme, host, nil, row.FileID)
	if u == "" {
		return
	}
	_, _ = models.Orm.QueryTable(new(models.SystemSoftwareUpgrade)).
		Filter("id", productID).
		Update(map[string]interface{}{"download_url": u})
}

func (c *PlatformSoftwareUpgradeController) rowToMap(row *models.SystemSoftwareUpgrade) map[string]interface{} {
	scheme, host := services.PublicRequestBaseURL(&c.Controller)
	resolved := services.ResolveSoftwareDownloadURL(scheme, host, row.DownloadURL, row.FileID)
	return map[string]interface{}{
		"id":                    row.ID,
		"name":                  row.Name,
		"code":                  row.Code,
		"latestVersion":         row.LatestVersion,
		"fileId":                row.FileID,
		"downloadUrl":           row.DownloadURL,
		"resolvedDownloadUrl":   resolved,
		"forceUpdate":           row.ForceUpdate,
		"releaseNotes":          row.ReleaseNotes,
		"status":                row.Status,
		"sort":                  row.Sort,
		"createTime":            row.CreateTime,
		"updateTime":            row.UpdateTime,
	}
}

// List GET /platform/softwareupgrade/list
func (c *PlatformSoftwareUpgradeController) List() {
	if _, err := c.platformClaims(); err != nil {
		c.jsonErr(401, 401, err.Error())
		return
	}
	page, _ := c.GetInt("page", 1)
	pageSize, _ := c.GetInt("pageSize", 20)
	if page < 1 {
		page = 1
	}
	if pageSize < 1 {
		pageSize = 20
	}
	if pageSize > 200 {
		pageSize = 200
	}
	keyword := strings.TrimSpace(c.GetString("keyword"))
	qs := models.Orm.QueryTable(new(models.SystemSoftwareUpgrade)).Filter("delete_time__isnull", true)
	if keyword != "" {
		cond := orm.NewCondition().Or("name__icontains", keyword).Or("code__icontains", keyword)
		qs = qs.SetCond(cond)
	}
	total, _ := qs.Count()
	var rows []models.SystemSoftwareUpgrade
	_, err := qs.OrderBy("sort", "-id").Limit(pageSize, (page-1)*pageSize).All(&rows)
	if err != nil {
		c.jsonErr(500, 500, "获取失败: "+err.Error())
		return
	}
	list := make([]map[string]interface{}, 0, len(rows))
	for i := range rows {
		list = append(list, c.rowToMap(&rows[i]))
	}
	c.ok(map[string]interface{}{
		"list": list, "total": total, "page": page, "pageSize": pageSize,
	})
}

// Detail GET /platform/softwareupgrade/:id
func (c *PlatformSoftwareUpgradeController) Detail() {
	if _, err := c.platformClaims(); err != nil {
		c.jsonErr(401, 401, err.Error())
		return
	}
	id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
	if err != nil || id == 0 {
		c.jsonErr(400, 400, "无效ID")
		return
	}
	var row models.SystemSoftwareUpgrade
	err = models.Orm.QueryTable(new(models.SystemSoftwareUpgrade)).
		Filter("id", id).
		Filter("delete_time__isnull", true).
		One(&row)
	if err != nil {
		c.jsonErr(404, 404, "记录不存在")
		return
	}
	c.ok(c.rowToMap(&row))
}

type softwareUpgradePayload struct {
	Name          *string `json:"name"`
	Code          *string `json:"code"`
	LatestVersion *string `json:"latestVersion"`
	FileID        *uint64 `json:"fileId"`
	DownloadURL   *string `json:"downloadUrl"`
	ForceUpdate   *int8   `json:"forceUpdate"`
	ReleaseNotes  *string `json:"releaseNotes"`
	Status        *int8   `json:"status"`
	Sort          *int    `json:"sort"`
}

// Create POST /platform/softwareupgrade
func (c *PlatformSoftwareUpgradeController) Create() {
	if _, err := c.platformClaims(); err != nil {
		c.jsonErr(401, 401, err.Error())
		return
	}
	body, _ := io.ReadAll(c.Ctx.Request.Body)
	var p softwareUpgradePayload
	if err := json.Unmarshal(body, &p); err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}
	if p.Name == nil || strings.TrimSpace(*p.Name) == "" || p.Code == nil || strings.TrimSpace(*p.Code) == "" {
		c.jsonErr(400, 400, "名称与产品标识 code 不能为空")
		return
	}
	v := "0.0.0"
	if p.LatestVersion != nil && strings.TrimSpace(*p.LatestVersion) != "" {
		v = strings.TrimSpace(*p.LatestVersion)
	}
	row := models.SystemSoftwareUpgrade{
		Name:          strings.TrimSpace(*p.Name),
		Code:          strings.TrimSpace(*p.Code),
		LatestVersion: v,
		DownloadURL:   p.DownloadURL,
		ForceUpdate:   0,
		Status:        1,
		Sort:          0,
	}
	if p.ForceUpdate != nil {
		row.ForceUpdate = *p.ForceUpdate
	}
	if p.ReleaseNotes != nil {
		row.ReleaseNotes = p.ReleaseNotes
	}
	if p.Status != nil {
		row.Status = *p.Status
	}
	if p.Sort != nil {
		row.Sort = *p.Sort
	}
	if p.FileID != nil && *p.FileID > 0 {
		row.FileID = p.FileID
	}
	id, err := models.Orm.Insert(&row)
	if err != nil {
		if strings.Contains(strings.ToLower(err.Error()), "duplicate") {
			c.jsonErr(400, 400, "产品标识 code 已存在")
			return
		}
		c.jsonErr(500, 500, "创建失败: "+err.Error())
		return
	}
	c.backfillDownloadURL(uint64(id))
	c.ok(map[string]interface{}{"id": id})
}

// Update POST /platform/softwareupgrade/:id
func (c *PlatformSoftwareUpgradeController) Update() {
	if _, err := c.platformClaims(); err != nil {
		c.jsonErr(401, 401, err.Error())
		return
	}
	id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
	if err != nil || id == 0 {
		c.jsonErr(400, 400, "无效ID")
		return
	}
	body, _ := io.ReadAll(c.Ctx.Request.Body)
	var p softwareUpgradePayload
	if err := json.Unmarshal(body, &p); err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}
	up := map[string]interface{}{}
	if p.Name != nil {
		up["name"] = strings.TrimSpace(*p.Name)
	}
	if p.Code != nil {
		up["code"] = strings.TrimSpace(*p.Code)
	}
	if p.LatestVersion != nil {
		up["latest_version"] = strings.TrimSpace(*p.LatestVersion)
	}
	if p.FileID != nil {
		if *p.FileID == 0 {
			up["file_id"] = nil
		} else {
			up["file_id"] = *p.FileID
		}
	}
	if p.DownloadURL != nil {
		up["download_url"] = strings.TrimSpace(*p.DownloadURL)
	}
	if p.ForceUpdate != nil {
		up["force_update"] = *p.ForceUpdate
	}
	if p.ReleaseNotes != nil {
		up["release_notes"] = *p.ReleaseNotes
	}
	if p.Status != nil {
		up["status"] = *p.Status
	}
	if p.Sort != nil {
		up["sort"] = *p.Sort
	}
	if len(up) == 0 {
		c.jsonErr(400, 400, "无更新字段")
		return
	}
	n, err := models.Orm.QueryTable(new(models.SystemSoftwareUpgrade)).
		Filter("id", id).
		Filter("delete_time__isnull", true).
		Update(up)
	if err != nil {
		c.jsonErr(500, 500, "更新失败: "+err.Error())
		return
	}
	if n == 0 {
		c.jsonErr(404, 404, "记录不存在")
		return
	}
	c.backfillDownloadURL(id)
	c.ok(nil)
}

// Delete DELETE /platform/softwareupgrade/:id
func (c *PlatformSoftwareUpgradeController) Delete() {
	if _, err := c.platformClaims(); err != nil {
		c.jsonErr(401, 401, err.Error())
		return
	}
	id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
	if err != nil || id == 0 {
		c.jsonErr(400, 400, "无效ID")
		return
	}
	now := time.Now()
	n, err := models.Orm.QueryTable(new(models.SystemSoftwareUpgrade)).
		Filter("id", id).
		Filter("delete_time__isnull", true).
		Update(map[string]interface{}{"delete_time": now})
	if err != nil {
		c.jsonErr(500, 500, "删除失败: "+err.Error())
		return
	}
	if n == 0 {
		c.jsonErr(404, 404, "记录不存在")
		return
	}
	c.ok(nil)
}