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 string

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

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

		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
	}

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

	// 验证用户
	fmt.Println("开始验证用户：", username)
	user, err := models.ValidateUser(username, password)
	fmt.Println("验证结果：", err)
	if user != nil {
		fmt.Println("用户信息：ID=", user.Id, "Username=", user.Username, "Salt=", user.Salt)
	}

	if err != nil {
		// 登录失败
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "用户名或密码错误",
			"data":    nil,
		}
	} else {
		// 使用models包中的GenerateToken函数生成token
		tokenString, err := models.GenerateToken(user.Id, user.Username)

		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,
					},
				},
			}
		}
	}

	c.ServeJSON()
}

// ResetPassword 重置用户密码
func (c *AuthController) ResetPassword() {
	// 获取请求参数
	username := c.GetString("username")
	superPassword := c.GetString("superPassword")

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

	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")

	// 调用模型方法
	err := models.ChangePassword(username, oldPassword, newPassword)
	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() {
	users := models.FindAllUsers()
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "获取用户列表成功",
		"data":    users,
	}
	c.ServeJSON()
}

// GetUserByUsername 通过用户名查询用户信息
func (c *AuthController) GetUserByUsername() {
	// 获取请求参数中的用户名
	username := c.GetString("username")
	if username == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "用户名不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型层方法查询用户
	user, err := models.GetUserByUsername(username) // 假设models层有这个方法
	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,
				// 其他需要返回的用户字段
			},
		}
	}
	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"`
	}

	// 解析请求体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
	}

	// 调用模型层方法添加用户（传递参数，接收新用户对象）
	newUser, err := models.AddUser(
		userData.Username,
		userData.Password,
		userData.Email,
		userData.Nickname,
		userData.Avatar,
	)
	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,
			},
		}
	}
	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"`   // 可选更新字段
	}

	// 解析请求体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不能为空）
	if updateData.Id == 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,
	)
	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,
			},
		}
	}
	c.ServeJSON()
}

// DeleteUser 删除用户
func (c *AuthController) DeleteUser() {
	// 获取要删除的用户ID（从URL参数或请求体中获取）
	userId, err := c.GetInt("id") // 从URL参数获取，如 /user?id=1
	if err != nil {
		// 若URL参数获取失败，尝试从JSON请求体获取
		var deleteData struct {
			Id int `json:"id"`
		}
		if err := json.Unmarshal(c.Ctx.Input.RequestBody, &deleteData); err != nil {
			c.Data["json"] = map[string]interface{}{
				"code":    1,
				"message": "用户ID获取失败: " + err.Error(),
				"data":    nil,
			}
			c.ServeJSON()
			return
		}
		userId = deleteData.Id
	}

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

	// 调用模型层方法删除用户
	err = models.DeleteUser(userId)
	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()
}