#coding=utf-8
'''
'''
import json
import datetime
import logging
import re
import time
import random

import hashlib
import xlrd
from django.core.cache import cache
from django.db.models import Q
from django.db.models import Sum
from django.db import transaction
from django.contrib import auth
import common.models as cm
import common.error_info as ce
import password_handle as ph
import common.common_functions as ccf
from utils.aestool import aescbc
import common.common_control as ccc

def add_user(request):
    """
    """
    kwargs = request.json
    need_params = ["realname","phone","department_id","utype","is_active"]
    mse = ccf.check_params(*need_params,**kwargs)
    if mse:
        raise ce.TipException(mse)
    if cm.UserInfo.objects.filter(phone=kwargs.get("phone")).exists():
        raise ce.TipException(u"该用户已存在!")
    need_params.extend(["email","remark"])
    cvals = ccf.get_need_params(*need_params,**kwargs)
    cvals.update({"name":cvals.get("phone")})
    cvals.update({"password":ph.make_password(cvals.get("phone")[-6:],True)})
    cvals["cid"] = request.user.id
    cvals["cperson"] = request.user.realname
    obj = cm.UserInfo.objects.create(**cvals)
    return obj


def delete_user(request):
    kwargs = request.json
    need_params = ["id"]
    mse = ccf.check_params(*need_params,**kwargs)
    if mse:
        raise ce.TipException(mse)
    ids = str(kwargs.get("id")).split(",")
    cm.UserInfo.objects.filter(id__in=ids).update(status=0)


def update_user(request):
    """
    """
    kwargs = request.json
    need_params = ["id"]
    mse = ccf.check_params(*need_params,**kwargs)
    if mse:
        raise ce.TipException(mse)
    id = kwargs.get("id")
    if cm.UserInfo.objects.exclude(id=id).filter(phone=kwargs.get("phone")).exists():
        raise ce.TipException(u"该用户已存在!")
    need_params.extend(["realname","phone","department_id","utype","is_active","email","remark"])
    cvals = ccf.get_need_params(*need_params,**kwargs)
    cvals.update({"name":cvals.get("phone")})
    cvals.update({"password":ph.make_password(cvals.get("phone")[-6:],True)})
    cvals["cid"] = request.user.id
    cvals["cperson"] = request.user.realname
    obj = cm.UserInfo.objects.filter(id=id).update(**cvals)
    return obj

def login_user(request):
    """
    """
    info = request.json
    username = info.get('username')
    password = info.get('password')
    utype = info.get('utype')
    captcha_id = info.get('imgcode_id')
    idcode = info.get('imgcode')
    captcha = cache.get(captcha_id, '')
    cache.delete(captcha_id)
    #if not username or not password:
    #    raise ce.TipException(u"账户或密码不能为空!")
    #if not idcode:
    #    raise ce.TipException(u"验证码不能为空!")
    #if idcode.upper() != captcha.upper():
    #    raise ce.TipException(u"验证码错误!")

    user = auth.authenticate(request, account=username, pwd=password)
    if user:
        auth.login(request, user)
        return user
    else:
        raise ce.TipException(u"账号或密码错误!")


def reset_password(request):
    """
    @attention: 重置密码
    """
    qdata = request.json
    need_params = ["password","repassword"]
    mse = ccf.check_params(*need_params,**qdata)
    if mse:
        raise ce.TipException(mse)
    uid = request.json.get("uid")
    if not uid:
        uid = request.user.id
    phone = qdata.get("phone")
    password = qdata.get("password")
    repassword = qdata.get("repassword")
    if password != repassword:
        raise ce.TipException(u"两次输入的密码不一致!")
    pwd = ph.make_password(password)
    cm.SysUserInfo.objects.filter(phone=phone).update(password=pwd)


def reset_user_password(request):
    qdata = request.json
    need_params = ["uid","code","password"]
    mse = ccf.check_params(*need_params,**qdata)
    if mse:
        raise ce.TipException(mse)
    upk = qdata.get("uid")
    code = qdata.get("code")
    pkey = request.user.phone
    if cache.get(pkey,"") != code:
        raise ce.TipException(u"验证码不正确!")
    newpwd = qdata.get("password")
    pwd = ph.make_password(newpwd)
    cm.UserInfo.objects.filter(pk=upk).update(password=pwd)


def regist_user(request):
    """
    """
    kwargs = request.json
    need_parms = ["realname","password","repassword","phone","email"]
    mse = ccf.check_params(*need_parms,**kwargs)
    if mse:
        raise ce.TipException(mse)
    if cm.UserInfo.objects.filter(phone=kwargs.get("phone")).exists():
        raise ce.TipException(u"该手机号已注册!")
    cvals = ccf.get_need_params(*need_parms,**kwargs)
    cvals.pop("repassword")
    cvals["name"] = cvals["phone"]
    if kwargs["password"] != kwargs["repassword"]:
        raise ce.TipException(u"前后输入的密码不一致!")
    if not cvals.get("password"):
        pwd,password = ph.make_default_password(None)
        cvals.update({"password":password})
    else:
        pwd = cvals.get("password")
        cvals.update({"password":ph.make_password(cvals.get("password"))})
    uobj = cm.UserInfo.objects.create(**cvals)
    return None


def format_user(*ids):
    """
    """
    eset = cm.SysUserInfo.objects.filter(id__in=ids,is_active=1)
    if not eset.exists():
        raise ce.TipException(u"账号不存在!")
    data = list(eset.values())
    return data

def get_user_info(request):
    """
    """
    kwargs = request.json
    need_params = ["id"]
    mse = ccf.check_params(*need_params,**kwargs)
    if mse:
        raise ce.TipException(mse)
    ids = str(kwargs.get("id")).split(",")
    info = format_user(*ids)
    info = info[0] if info else {}
    return info

def get_user_personal_info(request):
    """
    """
    id = request.user.id
    info = format_user(*[id])
    info = info[0] if info else {}
    return info

def get_account_info(request):
    """
    """
    id = request.user.id
    info = format_user(*[id])
    info = info[0] if info else {}
    info["p"] = ["Product.*.*"]
    return info

def get_user_list(request):
    """
    """
    kwargs = request.json
    eset = cm.UserInfo.objects.filter(status=1)
    if "name" in kwargs and kwargs.get("name"):
        eset = eset.filter(name__icontains=kwargs.get("name"))
    if "department_id" in kwargs and kwargs.get("department_id"):
        eset = eset.filter(department_id=kwargs.get("department_id"))
    if "utype" in kwargs and kwargs.get("utype"):
        eset = eset.filter(utype=kwargs.get("utype"))
    if "is_active" in kwargs and kwargs.get("is_active"):
        eset = eset.filter(is_active=kwargs.get("is_active"))
    total = eset.count()
    edata = list(eset.values())
    page = int(kwargs.get("page",1))
    page_size = int(kwargs.get("page_size",20))
    total,data = ccf.get_page_list(edata,page,page_size)
    return (total,data)


def get_unaudit_user_list(request):
    """
    """
    kwargs = request.json
    eset = cm.UserInfo.objects.filter(status=1,is_active=0)
    if "name" in kwargs and kwargs.get("name"):
        eset = eset.filter(name__icontains=kwargs.get("name"))
    if "utype" in kwargs and kwargs.get("utype"):
        eset = eset.filter(utype=kwargs.get("utype"))
    total = eset.count()
    edata = list(eset.values())
    page = int(kwargs.get("page",1))
    page_size = int(kwargs.get("page_size",20))
    total,data = ccf.get_page_list(edata,page,page_size)
    return (total,data)


def login_user_by_token(request):
    """
    """
    info = request.json
    name = info.get('name','')
    phone = info.get('phone','')
    phcode = info.get('phcode')
    role = info.get('role')

    if not phone:
        raise ce.TipException(u"缺少手机号!")
    if not phcode:
        raise ce.TipException(u"缺少验证码!")
    org_phcode = ccc.cache.get(phone)

    #if not org_phcode == phcode:
    #    raise ce.TipException(u"验证码错误!")

    if str(role)=="1":
        user = cm.Doctors.objects.filter(phone=phone,name=name).first()
    else:
        pinyin = ccf.get_name_pinyin(name)
        code = pinyin + ccf.get_now_str("%Y%m%d")
        user,flag = cm.Patients.objects.get_or_create(phone=phone,name=name)
        user.name = name
        user.code = code
        user.save()

    if not user:
        raise ce.TipException(u"医生不存在!")
    else:
        tstr = "{}_{}_{}{}".format(role,user.id,time.time(),random.randint(100000,999999))
        token = aescbc.encrypt(tstr)
        return {"id":user.id,"token":token,"status":1,"role":role}


def get_authinfo_by_token(request):
    """
    """
    user = request.user
    uid = user.get("id")
    role = user.get("role")
    if str(role) == "1":
        user = cm.Doctors.objects.filter(id=uid).values().first()
        user["doctor_role"] = user.get("role")
    else:
        user = cm.Patients.objects.filter(id=uid).values().first()
    user["role"] = role

    return user