using Apimanager_backend.Dtos;
using Apimanager_backend.Exceptions;
using Apimanager_backend.Models;
using Apimanager_backend.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.VisualBasic;

namespace Apimanager_backend.Controllers
{
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class AuthController : ControllerBase
    {
        private readonly IAuthService authService;
        private readonly ITokenService tokenService;
        private readonly IRefreshTokenService refreshTokenService;
        private readonly IUserService userService;
        public AuthController(IAuthService authService, ITokenService tokenService, IRefreshTokenService refreshTokenService,IUserService userService)
        {
            this.authService = authService;
            this.tokenService = tokenService;
            this.refreshTokenService = refreshTokenService;
            this.userService = userService;
        }
        /// <summary>
        /// 用户登录控制器
        /// </summary>
        /// <param name="dto">登录信息</param>
        /// <returns>通用返回信息格式</returns>
        [HttpPost]
        public async Task<ActionResult<ResponseBase<UserInfoDto>>> Login([FromBody] UserLoginDto dto)
        {
            try
            {
                UserInfoDto user = await authService.LoginAsync(dto.UserName, dto.Password);
                //生成token
            string token = tokenService.GenerateAccessToken(user.Id.ToString(), user.Roles);
                //生成refreshtoken
                string refreshToken = await refreshTokenService.CreateRefereshTokenAsync(user.Id.ToString());
                var responseInfo = new ResponseBase<LoginResponseDto>(
                        code: 2000,
                        message: "Login successful",
                        data: new LoginResponseDto
                        {
                            UserInfo = user,
                            Token = token,
                            RefreshToken = refreshToken
                        }
                    );
                return Ok(responseInfo);
            }
        /// <summary>
        /// 令牌刷新
        /// </summary>
        /// <param name="dto">传入用户令牌</param>
        /// <returns>返回新令牌</returns>
        [HttpPost]
        public async Task<ActionResult<ResponseBase<RefreshResponseDto?>>> Refresh([FromBody]RefreshResponseDto dto)
        {
            var IsRefreshToken = await refreshTokenService.ValidateRefreshTokenAsync(dto.UserId.ToString(),dto.RefreshToken);
                //刷新令牌无效
            if (!IsRefreshToken)
                {
                    var ret = new ResponseBase<RefreshResponseDto?>(
                            code: 2008,
                            message: "Refresh expires or is invalid",
                            data: null
                        );
                    return Unauthorized(ret);
                }
                //获取刷新令牌对应用户信息
            var userInfo = await userService.GetUserAsync(dto.UserId);
                //重新生成令牌
                var token = tokenService.GenerateAccessToken(userInfo.Id.ToString(), userInfo.Roles);
                //刷新刷新令牌有效期（小于三天才会刷新）
            await refreshTokenService.UpdateRefreshTokenAsync(userInfo.Id.ToString());
                var result = new ResponseBase<RefreshResponseDto?>(
                        code: 1000,
                        message: "Success",
                        data: new RefreshResponseDto
                        {
                        UserId = dto.UserId,
                            Token = token,
                            RefreshToken = dto.RefreshToken
                        }

                    );
                return Ok(result);
        }
        /// <summary>
        /// 用户注册
        /// </summary>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        public async Task<ActionResult<ResponseBase<UserInfoDto?>>> Register(RegisterRequestDto requestDto)
        {
            var isUsernameExist = await userService.IsUsernameExist(requestDto.Username);
            if (isUsernameExist)
            {
                var errorRes = new ResponseBase<UserInfoDto?>(
                        code:2003,
                        message:"用户名已存在",
                        data:null
                    );
                return StatusCode(409,errorRes);
            }
            try
            {
                var userInfo = await authService.RegisterAsync(requestDto);
                var res = new ResponseBase<UserInfoDto?>(
                        code:1000,
                        message:"Success",
                        data:userInfo
                    );
                return Ok(res);
            }catch(BaseException e)
            {
                var res = new ResponseBase<UserInfoDto?>(
                        code:e.code,
                        message:e.message,
                        data: null
                    );
                return StatusCode(500,res);
            }

            }
        /// <summary>
        /// 发送邮箱校验码
        /// </summary>
        /// <param name="registerRequestDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<ActionResult<ResponseBase<object?>>> SendValidateCode([FromQuery]string email)
        {
            //检测邮箱是否被使用
            var emailIsUse = await userService.IsEmailExist(email);
            if (emailIsUse)
            {
                var errorRes = new ResponseBase<object?>(
                        code:2005,
                        message: "邮箱已存在",
                        data:null
                    );
                return StatusCode(409,errorRes);
            }
            //发送注册验证码
            await authService.SendRegisterCodeAsync(email);
            var res = new ResponseBase<object?>(
                    code:1000,
                    message:"Success",
                    data: null
                );
            return Ok(res);
        }
            
        }
    }
}