package controllers

import (
	"encoding/json"
	"fmt"
	"server/models"

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

// 用于签名的密钥
var jwtSecret = []byte("yunzer_jwt_secret_key")

// AuthController 处理认证相关请求
type AuthController struct {
	beego.Controller
}

// Login 处理登录请求（支持租户模式，使用租户名称）
func (c *AuthController) Login() {
	var username, password, tenantName string

	// 优先尝试从URL参数获取（Apifox测试方式）
	username = c.GetString("username")
	password = c.GetString("password")
	tenantName = c.GetString("tenant_name")

	// 如果URL参数为空，尝试从JSON请求体获取（前端方式）
	if username == "" || password == "" || tenantName == "" {
		var loginData struct {
			Username   string `json:"username"`
			Password   string `json:"password"`
			TenantName string `json:"tenant_name"`
		}

		err := json.Unmarshal(c.Ctx.Input.RequestBody, &loginData)
		if err != nil {
			c.Data["json"] = map[string]interface{}{
				"code":    1,
				"message": "请求参数格式错误",
				"data":    nil,
			}
			c.ServeJSON()
			return
		}

		username = loginData.Username
		password = loginData.Password
		tenantName = loginData.TenantName
	}

	// 验证参数
	if tenantName == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "租户名称不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 添加日志调试
	fmt.Println("接收到的登录请求：")
	fmt.Println("用户名：", username)
	fmt.Println("租户名称：", tenantName)

	// 验证用户（先验证租户，再验证租户下的用户）
	fmt.Println("开始验证用户：", username, "租户：", tenantName)
	user, err := models.ValidateUser(username, password, tenantName)
	fmt.Println("验证结果：", err)
	if user != nil {
		fmt.Println("用户信息：ID=", user.Id, "Username=", user.Username, "TenantId=", user.TenantId)
	}

	if err != nil {
		// 登录失败
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": err.Error(),
			"data":    nil,
		}
	} else {
		// 使用models包中的GenerateToken函数生成token（包含租户ID）
		tokenString, err := models.GenerateToken(user.Id, user.Username, user.TenantId)

		if err != nil {
			c.Data["json"] = map[string]interface{}{
				"code":    1,
				"message": "生成token失败",
				"data":    nil,
			}
		} else {
			// 登录成功
			c.Data["json"] = map[string]interface{}{
				"code":    0,
				"message": "登录成功",
				"data": map[string]interface{}{
					"accessToken": tokenString,
					"token":       tokenString, // 兼容性
					"user": map[string]interface{}{
						"id":        user.Id,
						"username":  user.Username,
						"email":     user.Email,
						"avatar":    user.Avatar,
						"nickname":  user.Nickname,
						"tenant_id": user.TenantId,
					},
				},
			}
		}
	}

	c.ServeJSON()
}

// ResetPassword 重置用户密码（支持租户模式）
func (c *AuthController) ResetPassword() {
	// 获取请求参数
	username := c.GetString("username")
	superPassword := c.GetString("superPassword")
	tenantId, _ := c.GetInt("tenant_id", 0)

	// 如果URL参数中没有租户ID，尝试从JSON请求体获取
	if tenantId == 0 {
		var resetData struct {
			Username      string `json:"username"`
			SuperPassword string `json:"superPassword"`
			TenantId      int    `json:"tenant_id"`
		}
		if err := json.Unmarshal(c.Ctx.Input.RequestBody, &resetData); err == nil {
			username = resetData.Username
			superPassword = resetData.SuperPassword
			tenantId = resetData.TenantId
		}
	}

	if tenantId <= 0 {
		c.Data["json"] = map[string]interface{}{"success": false, "message": "租户ID不能为空"}
		c.ServeJSON()
		return
	}

	// 调用模型方法
	err := models.ResetPassword(username, superPassword, tenantId)

	if err != nil {
		c.Data["json"] = map[string]interface{}{"success": false, "message": err.Error()}
	} else {
		c.Data["json"] = map[string]interface{}{"success": true, "message": "密码重置成功"}
	}

	c.ServeJSON()
}

// ChangePassword 修改用户密码（支持租户模式）
func (c *AuthController) ChangePassword() {
	// 获取请求参数
	username := c.GetString("username")
	oldPassword := c.GetString("oldPassword")
	newPassword := c.GetString("newPassword")
	tenantId, _ := c.GetInt("tenant_id", 0)

	// 如果URL参数中没有租户ID，尝试从JSON请求体获取
	if tenantId == 0 {
		var changeData struct {
			Username    string `json:"username"`
			OldPassword string `json:"oldPassword"`
			NewPassword string `json:"newPassword"`
			TenantId    int    `json:"tenant_id"`
		}
		if err := json.Unmarshal(c.Ctx.Input.RequestBody, &changeData); err == nil {
			username = changeData.Username
			oldPassword = changeData.OldPassword
			newPassword = changeData.NewPassword
			tenantId = changeData.TenantId
		}
	}

	if tenantId <= 0 {
		c.Data["json"] = map[string]interface{}{"success": false, "message": "租户ID不能为空"}
		c.ServeJSON()
		return
	}

	// 调用模型方法
	err := models.ChangePassword(username, oldPassword, newPassword, tenantId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{"success": false, "message": err.Error()}
	} else {
		c.Data["json"] = map[string]interface{}{"success": true, "message": "密码修改成功"}
	}
	c.ServeJSON()
}

// Logout 处理登出请求
func (c *AuthController) Logout() {
	// 在实际应用中，这里需要处理JWT或Session的清除
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "登出成功",
	}
	c.ServeJSON()
}

// FindAllUsers 获取所有用户（支持按租户过滤）
func (c *AuthController) FindAllUsers() {
	// 从查询参数获取租户ID（可选）
	tenantId, _ := c.GetInt("tenant_id", 0)
	users := models.FindAllUsers(tenantId)
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "获取用户列表成功",
		"data":    users,
	}
	c.ServeJSON()
}

// GetUserByUsername 通过用户名查询用户信息（支持租户模式）
func (c *AuthController) GetUserByUsername() {
	// 获取请求参数中的用户名和租户ID
	username := c.GetString("username")
	tenantId, _ := c.GetInt("tenant_id", 0)

	if username == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "用户名不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	if tenantId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "租户ID不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型层方法查询用户
	user, err := models.GetUserByUsername(username, tenantId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "查询用户失败: " + err.Error(),
			"data":    nil,
		}
	} else if user == nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "用户不存在",
			"data":    nil,
		}
	} else {
		c.Data["json"] = map[string]interface{}{
			"code":    0,
			"message": "查询成功",
			"data": map[string]interface{}{
				"id":        user.Id,
				"username":  user.Username,
				"email":     user.Email,
				"avatar":    user.Avatar,
				"nickname":  user.Nickname,
				"tenant_id": user.TenantId,
			},
		}
	}
	c.ServeJSON()
}

// AddUser 添加新用户（支持租户模式）
func (c *AuthController) AddUser() {
	// 定义接收用户数据的结构体（与JSON请求体对应）
	var userData struct {
		Username string `json:"username"`
		Password string `json:"password"`
		Email    string `json:"email"`
		Nickname string `json:"nickname"`
		Avatar   string `json:"avatar"`
		TenantId int    `json:"tenant_id"`
	}

	// 解析请求体JSON数据
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &userData)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "请求参数格式错误: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 校验必要参数
	if userData.Username == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "用户名不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}
	if userData.Password == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "密码不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}
	if userData.TenantId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "租户ID不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型层方法添加用户（传递参数，接收新用户对象）
	newUser, err := models.AddUser(
		userData.Username,
		userData.Password,
		userData.Email,
		userData.Nickname,
		userData.Avatar,
		userData.TenantId,
	)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "添加用户失败: " + err.Error(),
			"data":    nil,
		}
	} else {
		c.Data["json"] = map[string]interface{}{
			"code":    0,
			"message": "用户添加成功",
			"data": map[string]interface{}{
				"id":        newUser.Id,
				"username":  newUser.Username,
				"email":     newUser.Email,
				"nickname":  newUser.Nickname,
				"avatar":    newUser.Avatar,
				"tenant_id": newUser.TenantId,
			},
		}
	}
	c.ServeJSON()
}

// UpdateUser 更新用户信息（支持租户模式）
func (c *AuthController) UpdateUser() {
	// 定义接收更新数据的结构体
	var updateData struct {
		Id       int    `json:"id"`        // 必须包含用户ID，用于定位要更新的用户
		Username string `json:"username"`  // 可选更新字段
		Email    string `json:"email"`     // 可选更新字段
		Nickname string `json:"nickname"`  // 可选更新字段
		Avatar   string `json:"avatar"`    // 可选更新字段
		TenantId int    `json:"tenant_id"` // 必须包含租户ID，用于验证用户归属
	}

	// 解析请求体JSON
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &updateData)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "请求参数格式错误: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 校验必要参数（用户ID和租户ID不能为空）
	if updateData.Id == 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "用户ID不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}
	if updateData.TenantId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "租户ID不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型层方法更新用户
	updatedUser, err := models.UpdateUser(
		updateData.Id,
		updateData.Username,
		updateData.Email,
		updateData.Nickname,
		updateData.Avatar,
		updateData.TenantId,
	)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "更新用户失败: " + err.Error(),
			"data":    nil,
		}
	} else {
		c.Data["json"] = map[string]interface{}{
			"code":    0,
			"message": "用户更新成功",
			"data": map[string]interface{}{
				"id":        updatedUser.Id,
				"username":  updatedUser.Username,
				"email":     updatedUser.Email,
				"nickname":  updatedUser.Nickname,
				"avatar":    updatedUser.Avatar,
				"tenant_id": updatedUser.TenantId,
			},
		}
	}
	c.ServeJSON()
}

// DeleteUser 删除用户（支持租户模式）
func (c *AuthController) DeleteUser() {
	// 获取要删除的用户ID和租户ID（从URL参数或请求体中获取）
	userId, err := c.GetInt("id") // 从URL参数获取，如 /user?id=1
	tenantId, _ := c.GetInt("tenant_id", 0)

	if err != nil || tenantId == 0 {
		// 若URL参数获取失败，尝试从JSON请求体获取
		var deleteData struct {
			Id       int `json:"id"`
			TenantId int `json:"tenant_id"`
		}
		if err := json.Unmarshal(c.Ctx.Input.RequestBody, &deleteData); err != nil {
			c.Data["json"] = map[string]interface{}{
				"code":    1,
				"message": "用户ID或租户ID获取失败: " + err.Error(),
				"data":    nil,
			}
			c.ServeJSON()
			return
		}
		userId = deleteData.Id
		tenantId = deleteData.TenantId
	}

	// 校验用户ID和租户ID
	if userId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "无效的用户ID",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}
	if tenantId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "租户ID不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型层方法删除用户
	err = models.DeleteUser(userId, tenantId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "删除用户失败: " + err.Error(),
			"data":    nil,
		}
	} else {
		c.Data["json"] = map[string]interface{}{
			"code":    0,
			"message": "用户删除成功",
			"data":    nil,
		}
	}
	c.ServeJSON()
}