package controllers

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

	"server/models"
	"server/pkg/identity"
	"server/pkg/jwtutil"
	"server/services"
	authsvc "server/services/auth"

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

// PlatformTenantApplyController 平台端「企业创建审核」
// 审批注册用户提交的创建企业申请：通过 → 自动建租户并把申请人绑定为租户管理员。
type PlatformTenantApplyController struct {
	beego.Controller
}

// platformClaims 入驻申请的审核接口只在平台端使用：必须是 platform 端令牌。
// 此前不判端，租户自己的令牌就能批准自己入驻，等于把审核权下发到了被审核方。
func (c *PlatformTenantApplyController) platformClaims() (*jwtutil.Claims, error) {
	return identity.Claims(c.Ctx.Request.Header.Get("Authorization"), identity.EndPlatform)
}

func (c *PlatformTenantApplyController) 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 *PlatformTenantApplyController) readJSON(v interface{}) bool {
	body := c.Ctx.Input.RequestBody
	if len(body) == 0 {
		var err error
		body, err = io.ReadAll(c.Ctx.Request.Body)
		if err != nil || len(body) == 0 {
			c.jsonErr(400, 400, "参数错误")
			return false
		}
	}
	if err := json.Unmarshal(body, v); err != nil {
		c.jsonErr(400, 400, "参数错误")
		return false
	}
	return true
}

// reviewerName 平台审核人姓名
func (c *PlatformTenantApplyController) reviewerName(claims *jwtutil.Claims) string {
	var admin models.AdminUser
	if err := models.Orm.QueryTable(new(models.AdminUser)).
		Filter("id", claims.UserID).
		One(&admin); err == nil && admin.Name != nil && strings.TrimSpace(*admin.Name) != "" {
		return strings.TrimSpace(*admin.Name)
	}
	return claims.Username
}

// List GET /platform/tenantApply/list?page=1&pageSize=20&type=&status=
func (c *PlatformTenantApplyController) List() {
	claims, err := c.platformClaims()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	_ = claims

	page, _ := c.GetInt("page", 1)
	pageSize, _ := c.GetInt("pageSize", 20)
	if page < 1 {
		page = 1
	}
	if pageSize < 1 {
		pageSize = 20
	}
	var applyType *int8
	if s := strings.TrimSpace(c.GetString("type")); s != "" {
		if v, e := strconv.ParseInt(s, 10, 8); e == nil {
			tmp := int8(v)
			applyType = &tmp
		}
	}
	var status *int8
	if s := strings.TrimSpace(c.GetString("status")); s != "" {
		if v, e := strconv.ParseInt(s, 10, 8); e == nil {
			tmp := int8(v)
			status = &tmp
		}
	}

	rows, total, err := services.ListTenantAppliesForPlatform(applyType, status, page, pageSize)
	if err != nil {
		c.jsonErr(500, 500, "获取申请列表失败")
		return
	}

	type applyDTO struct {
		models.AuthTenantApply
		IdentityNickname string `json:"identity_nickname"`
		IdentityMobile   string `json:"identity_mobile"`
	}
	list := make([]applyDTO, 0, len(rows))
	for _, r := range rows {
		dto := applyDTO{AuthTenantApply: r}
		if ident, ierr := authsvc.GetIdentityByID(r.IdentityID); ierr == nil && ident != nil {
			if ident.Nickname != nil {
				dto.IdentityNickname = *ident.Nickname
			}
			if ident.Mobile != nil {
				dto.IdentityMobile = *ident.Mobile
			}
		}
		list = append(list, dto)
	}

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

// Detail GET /platform/tenantApply/detail/:id
func (c *PlatformTenantApplyController) Detail() {
	claims, err := c.platformClaims()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	_ = claims

	id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
	if err != nil || id == 0 {
		c.jsonErr(400, 400, "无效ID")
		return
	}
	var apply models.AuthTenantApply
	if err := models.Orm.QueryTable(new(models.AuthTenantApply)).
		Filter("id", id).
		Filter("delete_time__isnull", true).
		One(&apply); err != nil {
		c.jsonErr(404, 404, "申请不存在")
		return
	}
	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": apply}
	_ = c.ServeJSON()
}

// Approve POST /platform/tenantApply/approve/:id
func (c *PlatformTenantApplyController) Approve() {
	claims, err := c.platformClaims()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, 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
	}
	tid, err := services.ApproveCreateApply(id, uint64(claims.UserID), c.reviewerName(claims))
	if err != nil {
		c.jsonErr(400, 400, err.Error())
		return
	}
	msg := "已通过，租户创建成功，申请人已绑定为该企业管理员"
	if tid > 0 {
		msg = fmt.Sprintf("已通过：租户已创建（ID:%d），申请人已绑定为企业管理员", tid)
	}
	c.Data["json"] = map[string]interface{}{"code": 200, "msg": msg, "data": map[string]interface{}{"tid": tid}}
	_ = c.ServeJSON()
}

// Reject POST /platform/tenantApply/reject/:id  { reason }
func (c *PlatformTenantApplyController) Reject() {
	claims, err := c.platformClaims()
	if err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	_ = claims
	id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
	if err != nil || id == 0 {
		c.jsonErr(400, 400, "无效ID")
		return
	}
	var req struct {
		Reason string `json:"reason"`
	}
	if !c.readJSON(&req) {
		return
	}
	if err := services.RejectCreateApply(id, uint64(claims.UserID), c.reviewerName(claims), strings.TrimSpace(req.Reason)); err != nil {
		c.jsonErr(400, 400, err.Error())
		return
	}
	c.Data["json"] = map[string]interface{}{"code": 200, "msg": "已驳回"}
	_ = c.ServeJSON()
}