import json

import pymongo
from bson import ObjectId
from fastapi import APIRouter, Depends, Request
from fastapi.encoders import jsonable_encoder
from motor.motor_asyncio import AsyncIOMotorDatabase
from redis import Redis

import crud, schemas
from core.config import settings
from core.security import get_password_hash

from db import get_database
from api import deps
from db.ckdb import CKDrive, get_ck_db
from db.redisdb import get_redis_pool, RedisDrive

# from utils import casbin_enforcer

router = APIRouter()

# 疑似弃用
@router.post('/add_data_auth')
async def add_data_auth(request: Request,
                        data_id: schemas.DataAuthCreate,
                        game: str = Depends(deps.get_game_project),
                        db: AsyncIOMotorDatabase = Depends(get_database),
                        current_user: schemas.UserDB = Depends(deps.get_current_user)
                        ) -> schemas.Msg:
    """创建数据权限"""
    await crud.data_auth.create(db, data_id, game)
    return schemas.Msg(code=0, msg='ok', data=data_id)

# 疑似弃用
@router.post('/edit_data_auth')
async def edit_data_auth(request: Request,
                         data_id: schemas.DataAuthEdit,
                         game: str,
                         db: AsyncIOMotorDatabase = Depends(get_database),
                         current_user: schemas.UserDB = Depends(deps.get_current_user)
                         ) -> schemas.Msg:
    """修改数据权限"""
    await crud.data_auth.edit_data_auth(db, data_id)
    return schemas.Msg(code=0, msg='ok', data=data_id)

#各数据类型在分析指标时可支持的计算方法
@router.get("/quotas_map")
async def quotas_map(
        request: Request,
        game: str,
        current_user: schemas.UserDB = Depends(deps.get_current_user)
) -> schemas.Msg:
    return schemas.Msg(code=0, msg='ok', data=settings.CK_OPERATOR)


@router.get("/filter_map")
async def filter_map(
        request: Request,
        game: str,
        current_user: schemas.UserDB = Depends(deps.get_current_user)
) -> schemas.Msg:
    # ck中，不同的数据类型的不同计算规则
    return schemas.Msg(code=0, msg='ok', data=settings.CK_FILTER)


@router.get('/all_event')
async def all_event(request: Request,
                    game: str,
                    ck: CKDrive = Depends(get_ck_db),
                    db: AsyncIOMotorDatabase = Depends(get_database),
                    current_user: schemas.UserDB = Depends(deps.get_current_user)
                    ) -> schemas.Msg:
    """获取所有事件"""
    values = await ck.distinct(game, 'event', '#event_name')
    values.sort()
    return schemas.Msg(code=0, msg='ok', data=values)


@router.get("/list")
async def data_authority(request: Request,
                         game: str,
                         db: AsyncIOMotorDatabase = Depends(get_database),
                         rdb: RedisDrive = Depends(get_redis_pool),
                         ck: CKDrive = Depends(get_ck_db),
                         current_user: schemas.UserDB = Depends(deps.get_current_user)
                         ) -> schemas.Msg:
    """获取前项目数据权限"""
    total_event = await ck.distinct_count(game, 'event', '#event_name')
    data = await crud.data_auth.get_game_data_auth(db, game)
    for item in data:
        item['id'] = str(item['_id'])
        del item['_id']
        item['data_range'] = f'{len(item["data"])}/{total_event}'

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


@router.get("/my_event")
async def my_event(request: Request,
                   game: str,
                   db: AsyncIOMotorDatabase = Depends(get_database),
                   rdb: RedisDrive = Depends(get_redis_pool),
                   ck: CKDrive = Depends(get_ck_db),
                   current_user: schemas.UserDB = Depends(deps.get_current_user)
                   ) -> schemas.Msg:
    """获取自己的事件权限"""
    event_list = []
    # start_date = (datetime.datetime.now()-datetime.timedelta(days=30)).strftime('%Y-%m-%d %H:%M:%S')
    # where = f"""`#event_time` > '{start_date}'"""
    # my_data_auth = await ck.distinct(game, 'event', '#event_name',where)
    my_data_auth = await rdb.smembers(f'{game}_event_set')

    #
    # else:
    #     # 设置了数据权限
    #     my_data_auth = await crud.data_auth.get(db, ObjectId(data_auth_id))
    #     my_data_auth = my_data_auth['data']

    event_show_name, event_show_label_id= await crud.event_mana.get_all_show_name(db, game)
    event_list.append({'id': 'event', 'title': '全部事件', 'category': []})
    for item in my_data_auth:
        event_list[-1]['category'].append({
            'event_name': item,
            'event_desc': event_show_name.get(item, item),
            'event_label':event_show_label_id.get(item,'')
        })
    event_list[-1]['category'].append({'event_name': '*', 'event_desc': '任意事件','event_label':''})
    event_list.sort()
    return schemas.Msg(code=0, msg='ok', data=event_list)


@router.get("/user_property")
async def user_property(request: Request,
                        game: str,
                        db: AsyncIOMotorDatabase = Depends(get_database),
                        rdb: RedisDrive = Depends(get_redis_pool),
                        ck: CKDrive = Depends(get_ck_db),
                        current_user: schemas.UserDB = Depends(deps.get_current_user)
                        ) -> schemas.Msg:
    """获取用户属性"""
    data = await rdb.get(f'{game}_user')
    data = json.loads(data)
    propertys = []

    data_attr = await crud.data_attr.find_many(db, {'game': game, 'cat': 'user'})
    data_attr = {item['name']: item for item in data_attr}

    for k, v in data.items():
        data_type = settings.CK_TYPE_DICT.get(v)
        propertys.append(
            {'name': k,
             'data_type': data_type,
             'show_name': data_attr.get(k, {}).get('show_name', ''),
             }
        )
    propertys = sorted(propertys, key=lambda x: x['show_name'])  # 按show_name排序

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


@router.post('/load_prop_quotas')
async def load_prop_quotas(request: Request,
                           game: str,
                           data_in: schemas.LoadProQuotas,
                           db: AsyncIOMotorDatabase = Depends(get_database),
                           rdb: RedisDrive = Depends(get_redis_pool),
                           ck: CKDrive = Depends(get_ck_db),
                           current_user: schemas.UserDB = Depends(deps.get_current_user)
                           ) -> schemas.Msg:
    """事件属性 聚合条件"""

    event_columns = await ck.get_columns(game, 'event')  # 获取字段名和字段类型

    data_attr = await crud.data_attr.find_many(db, {'game': game, 'cat': 'event'})
    data_attr = {item['name']: item for item in data_attr}
    event_props = []
    for item in event_columns:
        data_type = settings.CK_TYPE_DICT.get(item['type'])
        title = data_attr.get(item['name'], {}).get('show_name') or item['name']
        event_prop = {
            'id': item['name'],
            'data_type': data_type,
            'title': title,
            # 'category': settings.CK_OPERATOR.get(data_type) or []
        }
        event_props.append(event_prop)
    if data_in.model == 'scatter':
        staid_quots = [
            {
                "id": "*",
                "data_type": None,
                "analysis": "times",
                "title": "次数",
            },
            {
                "id": "*",
                "data_type": None,
                "analysis": "number_of_days",
                "title": "天数",
            },
            {
                "id": "*",
                "data_type": None,
                "analysis": "number_of_hours",
                "title": "小时数",
            },
        ]
    else:
        staid_quots = [
            {
                "id": "*",
                "data_type": None,
                "analysis": "total_count",
                "title": "总次数",
            },
            {
                "id": "*",
                "analysis": "touch_user_count",
                "data_type": None,
                "title": "触发用户数",
            },
            {
                "id": "*",
                "analysis": "touch_user_avg",
                "data_type": None,
                "title": "人均次数",
            },
        ]

    res = {
        'props': event_props,
        'staid_quots': staid_quots

    }

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


@router.post('/load_filter_props')
async def load_filter_props(request: Request,
                            game: str,
                            data_in: schemas.LoadProQuotas,
                            db: AsyncIOMotorDatabase = Depends(get_database),
                            rdb: RedisDrive = Depends(get_redis_pool),
                            ck: CKDrive = Depends(get_ck_db),
                            current_user: schemas.UserDB = Depends(deps.get_current_user)
                            ) -> schemas.Msg:
    """事件属性 过滤条件"""

    event_columns = await ck.get_columns(game, 'event')
    user_columns = await ck.get_columns(game, 'user')

    data_attr = await crud.data_attr.find_many(db, {'game': game, 'cat': 'event'})
    data_attr = {item['name']: item for item in data_attr}
    event_props = []
    for item in event_columns:
        data_type = settings.CK_TYPE_DICT.get(item['type'])
        title = data_attr.get(item['name'], {}).get('show_name') or item['name']
        event_prop = {
            'id': item['name'],
            'data_type': data_type,
            'title': title,
        }
        event_props.append(event_prop)

    data_attr = await crud.data_attr.find_many(db, {'game': game, 'cat': 'user'})
    data_attr = {item['name']: item for item in data_attr}
    user_props = []
    for item in user_columns:
        data_type = settings.CK_TYPE_DICT.get(item['type'])
        title = data_attr.get(item['name'], {}).get('show_name') or item['name']
        user_prop = {
            'id': item['name'],
            'data_type': data_type,
            'title': title,
        }
        user_props.append(user_prop)

    user_label_props = []
    user_label_docs = await crud.user_label.find_many(db, {'game': game}, {'qp': 0})
    for item in user_label_docs:
        tmp = {
            'id': item['cluster_name'],
            'data_type': 'user_label',
            'title': item['display_name'],
        }
        user_label_props.append(tmp)
    res = [
        {
            'title': '事件属性',
            'id': 'event',
            'category': event_props
        },
        {
            'title': '用户属性',
            'id': 'user',
            'category': user_props
        },
        {
            'title': '用户标签',
            'id': 'user_label',
            'category': user_label_props
        }
    ]

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