from datetime import datetime
from logging import error
from flasgger import swag_from
from app.util import BlueprintApi
from flask import Blueprint, render_template, redirect, request, session, jsonify, flash, make_response
from .models import *
from .oauth2 import authorization, generate_user_info, require_oauth
from authlib.oauth2 import OAuth2Error
from authlib.integrations.flask_oauth2 import current_token
from . import user_create, client_create, client_query, user_query, user_update, user_delete, auth_log_query
import configure
from app.decorators.auth_decorator import auth_decorator
import time
from app.models import SM3, AESHelper
from app.util.component.StructurePrint import StructurePrint
import traceback
# from oauthlib import oauth2
import requests
from app.modules.auth.models import OAuth2Token, User, db, OAuthLog
from app.util.enum.AuthEnum import AuthEnum, OriginEnum, OperateEnum


def current_user():
    if "id" in session:
        uid = session["id"]
        return User.query.get(uid)
    return None


def remove_user():
    user = current_user()
    if user:
        session.pop("id")


def split_by_crlf(s):
    return [v for v in s.splitlines() if v]


def getRedirectUrl(request):  # 获取重定向地址
    # 获取头部信息
    X_Forwarded_Proto = request.headers.get("X-Forwarded-Proto")  # 协议
    X_Forwarded_Host = request.headers.get("X-Forwarded-Host")  # host
    if not X_Forwarded_Proto == None and not X_Forwarded_Host == None:
        return X_Forwarded_Proto+"://"+X_Forwarded_Host
    else:
        return request.host_url.rstrip("/")


class DataManager(BlueprintApi):
    bp = Blueprint("Auth", __name__, url_prefix="/auth")

    @staticmethod
    @bp.route("/authorize", methods=("GET", "POST"))
    def authorize():
        user = current_user()
        request2 = authorization.create_oauth2_request(request)
        grant2 = authorization.get_authorization_grant(request=request2)
        redirect_uri = grant2.validate_authorization_request()
        session["redirect_uri"] = redirect_uri  # 记录跳转重定向地址
        if request.method == "GET":
            # 没有登录，跳转到登录界面
            try:
                grant = authorization.validate_consent_request(end_user=user)
            except OAuth2Error as error:
                return jsonify(dict(error.get_body()))
            if not user:
                # 生成验证码

                return render_template("auth/authorize.html",
                                       user=user,
                                       grant=grant)
        error = ""
        if not user:
            # 验证码校验

            if not "username" in request.form or not request.form.get("username"):
                error = "用户名不可为空"
            elif not "password" in request.form or not request.form.get("password"):
                error = "密码不可为空"
            else:
                username = request.form.get("username")
                crypt_pwd = request.form.get("password")
                # password = SM3.encode(crypt_pwd)
                password = SM3.encode(AESHelper.decode(crypt_pwd))

                # 仅支持dmap平台保留用户登录
                origin_type = OriginEnum.Dmap.name.lower()
                user = User.query.filter_by(
                    username=username, password=password, origin=origin_type).first()
                if not user:
                    error = "账号或密码不正确"
                    flash(error)
                    # return render_template("auth/authorize.html",
                    #                    grant_user=None,error=error)

        flash(error)
        if user:
            session["id"] = user.id
            grant_user = user

            # 日志
            log = OAuthLog(user_id=user.id, username=user.username,
                           auth_type=AuthEnum.Other.name.lower(),
                           message="认证成功", create_time=datetime.now(),
                           operate_type=OperateEnum.Login,
                           displayname=user.displayname, ip=request.remote_addr
                           )
            db.session.add(log)
            db.session.commit()

            return authorization.create_authorization_response(request=request, grant_user=grant_user)

        # try:
        #     grant = authorization.validate_consent_request(end_user=user)
        # except OAuth2Error as error:
        #     return jsonify(dict(error.get_body()))
        # return render_template("auth/authorize.html", user=user, grant=grant, error=error)
        try:
            grant = authorization.validate_consent_request(end_user=user)
        except OAuth2Error as error:
            return jsonify(dict(error.get_body()))
        return render_template("auth/authorize.html",
                               grant_user=None, error=error)

    @staticmethod
    @bp.route("/token", methods=["POST"])
    def issue_token():
        return authorization.create_token_response()

    @staticmethod
    @bp.route("/userinfo")
    @require_oauth("profile")
    def api_me():
        try:
            return jsonify(generate_user_info(current_token.user, current_token.scope))
        except error as e:
            return jsonify(dict(e.get_body()))

    @staticmethod
    @bp.route("/logout", methods=["GET"])
    def logout():
        try:
            request2 = authorization.create_oauth2_request(request)
            grant1 = authorization.get_authorization_grant(
                request=request2)
            redirect_uri = grant1.validate_authorization_request()
            access_token = request.args.get("accesstoken")

            if not access_token == None:
                accesstoken = OAuth2Token.query.filter_by(
                    access_token=access_token).one_or_none()
                if not accesstoken == None:
                    accesstoken.revoked = True
                    db.session.commit()
                    if current_user() != None:
                        remove_user()

                    user = User.query.get(accesstoken.user_id)
                    # 日志
                    if user != None:
                        log = OAuthLog(user_id=user.id, username=user.username,
                                       auth_type=AuthEnum.Other.name.lower(),
                                       message="注销成功", create_time=datetime.now(),
                                       operate_type=OperateEnum.Logout, token=access_token,
                                       displayname=user.displayname, ip=request.remote_addr
                                       )
                        db.session.add(log)
                        db.session.commit()

        except OAuth2Error as error:
            StructurePrint().print(error.__str__()+":" + traceback.format_exc(), "error")
        return redirect(redirect_uri)

    """接口"""
    @staticmethod
    @bp.route("/users", methods=["GET"])
    @swag_from(user_query.Api.api_doc)
    @auth_decorator(configure.UserPermission)
    def user_query():
        """
        获取用户列表
        """
        return user_query.Api().result

    @staticmethod
    @bp.route("/users", methods=["POST"])
    @swag_from(user_create.Api.api_doc)
    @auth_decorator(configure.UserPermission)
    def user_create():
        """
        创建用户
        """
        return user_create.Api().result

    @staticmethod
    @bp.route("/userEdit", methods=["POST"])
    @swag_from(user_update.Api.api_doc)
    @auth_decorator(configure.UserPermission)
    def user_update():
        """
        更新用户信息
        """
        return user_update.Api().result

    @staticmethod
    @bp.route("/userDelete", methods=["POST"])
    @swag_from(user_delete.Api.api_doc)
    @auth_decorator(configure.UserPermission)
    def user_delete():
        """
        删除用户
        """
        return user_delete.Api().result

    @staticmethod
    @bp.route("/client", methods=["POST"])
    @swag_from(client_create.Api.api_doc)
    def client_create():
        """
        创建client
        """
        return client_create.Api().result

    @staticmethod
    @bp.route("/client", methods=["GET"])
    @swag_from(client_query.Api.api_doc)
    def client_query():
        """
        获取client列表
        """
        return client_query.Api().result

    @staticmethod
    @bp.route("/init", methods=["GET"])
    def init():
        try:
            username = 'admin'
            password = SM3.encode('DMap@123')
            if not User.query.filter_by(username=username).one_or_none():
                user = User(username=username, password=password, role='admin',
                            phone='', company='', position='', email='',
                            create_time=time.strftime(
                                "%Y-%m-%d %H:%M:%S", time.localtime()),
                            update_time=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
                db.session.add(user)
                db.session.commit()
                return "创建默认用户成功"
            else:
                return "默认用户已存在"
        except Exception as e:
            StructurePrint().print(e.__str__()+":" + traceback.format_exc(), "error")

    # @staticmethod
    # @bp.route("/translate", methods=["GET"])
    # def translate():
    #     password = ['esri@123', 'admin', 'DMap@123', 'passwd','dci112..']
    #     result = {}
    #     for p in password:
    #         new_pwd = SM3.encode(p)
    #         result[p] = new_pwd
    #     return result

    '''
    三方登录：OA
    '''
    @staticmethod
    @bp.route("/oa", methods=["GET"])
    def oa_authorization():
        client = oauth2.WebApplicationClient(
            configure.OA["client_id"])
        state = client.state_generator()
        StructurePrint().print(request.headers, "info")
        auth_uri = client.prepare_request_uri(
            configure.OA["authorization_endpoint"], getRedirectUrl(request) + configure.OA["redirect_uri"], configure.OA["scope"], state)
        session["oauth_state"] = state
        return redirect(auth_uri)

    '''
    oa三方登录回调
    '''
    @staticmethod
    @bp.route("/oa/callback", methods=["GET"])
    def oa_callback():
        try:
            auth_default_redirect_uri = configure.auth_default_redirect_uri
            client = oauth2.WebApplicationClient(
                configure.OA["client_id"])

            # 获取code
            code = client.parse_request_uri_response(
                request.url, session["oauth_state"]).get("code")

            if code == None:
                return "登录失败"

            # 获取token
            body = client.prepare_request_body(
                code, redirect_uri=getRedirectUrl(request) + configure.OA["redirect_uri"], client_secret=configure.OA["client_secret"])

            r = requests.post(configure.OA["token_endpoint"], body, headers={
                "Content-Type": "application/x-www-form-urlencoded"})

            tokeninfo = r.json()
            access_token = tokeninfo.get("access_token")
            id_token = tokeninfo.get("id_token")

            origin_type = "dci_oa"  # 三方登录标识
            if access_token:
                # 获取用户信息
                userinfo_url = configure.OA["userinfo_endpoint"]
                user_request = requests.get(userinfo_url, headers={
                                            "Authorization": "Bearer %s" % access_token})
                userinfo = user_request.json()
                user_name = userinfo.get("user_name")
                display_name = userinfo.get("displayname")
                display_name = display_name.split(
                )[-1] if display_name != None else user_name

                # 默认关联dmap用户
                try:
                    user = User.query.filter_by(
                        username=user_name, origin=origin_type).first()
                except error as e:
                    user = None

                # 用户不存在，创建用户

                if not user:
                    user = User(username=user_name, password=SM3.encode('DMap@123'), role='dataman',
                                phone='', company='', position='', email='', displayname=display_name,
                                origin=origin_type,
                                create_time=time.strftime(
                                    "%Y-%m-%d %H:%M:%S", time.localtime()),
                                update_time=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
                    db.session.add(user)
                    db.session.commit()

                session["id"] = user.id

                # dmap token授权
                # 存入数据库
                token = OAuth2Token(
                    client_id=configure.OA["client_id"],
                    token_type=tokeninfo.get("token_type"),
                    access_token=access_token,
                    scope=tokeninfo.get("scope"),
                    expires_in=tokeninfo.get("expires_in"),
                    user_id=user.id
                )

                db.session.add(token)
                db.session.commit()

                redirect_uri = session["redirect_uri"] if "redirect_uri" in session else auth_default_redirect_uri

                #session["id_token"] = id_token
                response = make_response(redirect(redirect_uri))
                response.set_cookie('accessToken', access_token,
                                    max_age=configure.expiretime)
                response.set_cookie('id_token', id_token,
                                    max_age=configure.expiretime)

                log = OAuthLog(user_id=user.id, username=user_name,
                               auth_type=AuthEnum.Other.name.lower(),
                               message="三方认证成功", create_time=datetime.now(),
                               operate_type=OperateEnum.Login, token=access_token,
                               displayname=display_name, ip=request.remote_addr)
                db.session.add(log)
                db.session.commit()

                return response
            else:
                raise Exception("缺少access_token")

        except Exception as e:
            StructurePrint().print(e.__str__()+":" + traceback.format_exc(), "error")
            pop_list = ["id", "redirect_uri"]
            for p in pop_list:
                if p in session:
                    session.pop(p)
        return redirect(auth_default_redirect_uri)

    @staticmethod
    @bp.route("/logs", methods=["GET"])
    @swag_from(auth_log_query.Api.api_doc)
    @auth_decorator(configure.UserPermission)
    def authLog():
        '''
        登录日志
        '''
        return auth_log_query.Api().result