from datetime import timedelta
from typing import Any

import redis
from fastapi import APIRouter, Body, Depends, HTTPException, Request
from fastapi.security import OAuth2PasswordRequestForm
from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase

import crud, schemas
from api import deps
from core import security
from core.config import settings
from db.redisdb import RedisDrive, get_redis_pool
from utils import get_uid, random_hex
from db import get_database
from utils.dingding import send_dates

router = APIRouter()

host = settings.REDIS_CONF.get('host')
port = settings.REDIS_CONF.get('port')
db = settings.REDIS_CONF.get('db')
password = settings.REDIS_CONF.get('password')
redisdb = redis.Redis(host=host, port=port, db=db,password=password)

@router.post("/send_auth_code")
async def reset_password(request: Request,
                         data_in: schemas.send,
                         db: AsyncIOMotorDatabase = Depends(get_database),
                         rdb: RedisDrive = Depends(get_redis_pool)
                         ):
    """发送验证码"""
    res= await crud.user.get_by_user(db,data_in.name)
    user_id=res['user_id']
    # X平台登陆提醒：你的验证码是7933
    if res['types'] == 1: # 内部员工发送验证码
        code=random_hex(4)
        content=f'X平台登陆提醒：你的验证码是{code}'
        send_dates(content, [user_id])  # 发送验证码
        redisdb.set(name=user_id, value=code, ex=120)  # 120秒
    return schemas.Msg(code=0, msg='ok',data='')


@router.post("/login")
async def login(
        # data: schemas.UserLogin,
        #code:str,
        data: OAuth2PasswordRequestForm = Depends(),
        db: AsyncIOMotorDatabase = Depends(get_database)
) -> Any:
    """
    OAuth2兼容令牌登录，获取将来令牌的访问令牌
    """
    user = await crud.user.authenticate(db,
                                        name=data.username, password=data.password
                                        )
    if user.types == 1: # 内部员工校验验证码
        rdbcode=redisdb.get(user.user_id)
        if rdbcode == None:
            return schemas.Msg(code=-1, msg='验证码过期')
        if rdbcode.decode() != data.scopes[0]:
            return schemas.Msg(code=-1, msg='验证码错误')
    if not user:
        # raise HTTPException(status_code=400, detail="Incorrect name or password")
        return schemas.Msg(code=-1, msg='密码或用户名错误')
    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
    # access_token_expires = timedelta(seconds=5)
    await crud.user.update_login_time(db, data.username)

    return {
        'data': {
            'name': user.name,
            'nickname': user.nickname,
            'email': user.email,
            'tel': user.tel,
            'userid': user.id,

            'token': security.create_access_token(
                expires_delta=access_token_expires, _id=str(user.id), email=user.email,
                nickname=user.nickname,
                is_superuser=user.is_superuser, name=user.name,
                data_where=user.data_where,
            ),
            "token_type": "bearer",

        },
        'access_token': security.create_access_token(
            expires_delta=access_token_expires, _id=str(user.id), email=user.email,
            nickname=user.nickname,
            is_superuser=user.is_superuser, name=user.name, data_where=user.data_where
        ),
        "token_type": "bearer",

        'code': 0,
        'msg': 'success',
    }


@router.get("/me", response_model=schemas.User)
def me(current_user: schemas.User = Depends(deps.get_current_user)) -> Any:
    """
    Test access token
    """
    return current_user


@router.post("/reset_password")
async def reset_password(request: Request,
                         game: str,
                         data_in: schemas.UserRestPassword,
                         db: AsyncIOMotorDatabase = Depends(get_database),
                         current_user: schemas.User = Depends(deps.get_current_user)
                         ) -> Any:
    """
    修改其他人密码
    """
    try:
        await crud.user.reset_password(db, data_in)
    except Exception as e:
        return schemas.Msg(code=0, msg='修改失败', data={'username': data_in})
    return schemas.Msg(code=0, msg='ok')


@router.post("/reset_my_password")
async def reset_password(request: Request,
                         game: str,
                         data_in: schemas.UserRestMyPassword,
                         db: AsyncIOMotorDatabase = Depends(get_database),
                         current_user: schemas.User = Depends(deps.get_current_user)
                         ) -> Any:
    """
    修改自己的密码
    """
    await crud.user.reset_password(db, schemas.UserRestPassword(username=current_user.name, password=data_in.password))
    return schemas.Msg(code=0, msg='ok')


@router.post("/edit_profile")
async def edit_profile(request: Request,
                       game: str,
                       data_in: schemas.UserProfileEdit,
                       db: AsyncIOMotorDatabase = Depends(get_database),
                       current_user: schemas.User = Depends(deps.get_current_user)
                       ) -> Any:
    """
    编辑用户资料
    """
    await crud.user.edit_profile(db, data_in, user_id=request.user.id)
    return schemas.Msg(code=0, msg='ok', data=data_in)


@router.get("/all_account")
async def all_account(page: int = 1, limit: int = 100, db: AsyncIOMotorDatabase = Depends(get_database),
                      current_user: schemas.User = Depends(deps.get_current_user)
                      ) -> Any:
    """
    获取所有用户
    """
    page -= 1
    if page < 0:
        page = 0
    cursor = crud.user.find(db).skip(page * limit).limit(limit)

    data = [schemas.UserDB(**user) async for user in cursor]

    return schemas.Msg(code=0, msg='ok', data=data)


@router.post("/add_account")
async def all_account(
        data_in: schemas.CreateAccount,
        db: AsyncIOMotorDatabase = Depends(get_database),
        current_user: schemas.User = Depends(deps.get_current_user)
) -> schemas.Msg:
    """
    创建新账号
    """
    created = []
    id = []
    for name in data_in.account_list:
        if is_exists := await crud.user.exists(db, {'name': name}):
            continue
        else:
            new_account = schemas.UserCreate(name=name, password='123')
            created.append(name)
            # 创建账户并返回id
            id_one = await crud.user.create(db, new_account)
            id.append(id_one)
    res = {
        'created_account': created,
        'password': '123',
        'id': id
    }
    return schemas.Msg(code=0, msg='ok', data=res)