from django.http import HttpResponse,JsonResponse
from django.shortcuts import render
from django.shortcuts import redirect
from .models import Group, GroupUser
from .forms import GroupUserForm, UserForm
from safesite import models as s_models
from safesite.tasks import gettime
import requests
import json
import time
from datetime import datetime,date,timedelta
from django.core.serializers.json import DjangoJSONEncoder
from django.db.models import Q,F,Count,Sum
from django.forms.models import model_to_dict
from django.http import Http404

def check_login(func):  # 自定义登录验证装饰器
    def warpper(request,*args,**kwargs):
        is_login = request.session.get('is_login', False)
        if is_login:
            return func(request,*args,**kwargs)
        else:
            return redirect('/groups/login')
    return warpper

def login(request):
    # 不允许重复登录
    if request.session.get('is_login', None):
        return redirect('/groups/index/')
    if request.method == "POST":
        groups_form = GroupUserForm(request.POST)
        message = '请检查填写的内容！'
        if groups_form.is_valid():
            username = groups_form.cleaned_data.get('username')
            password = groups_form.cleaned_data.get('password')

            try:
                user = GroupUser.objects.get(username=username)
            except:
                message = '用户不存在！'
                return render(request, 'groups/login.html', locals())
            if user.password == password:
                request.session['is_login'] = True
                request.session['user_id'] = user.id
                request.session['user_name'] = user.username
                return redirect('/groups/index/')
            else:
                return render(request, 'groups/login.html', locals())
        else:
            return render(request, 'groups/login.html', locals())
    groups_form = GroupUserForm()
    return render(request, 'groups/login.html', locals())

def logout(request):
    # if not request.session.get('is_login', None):
    #     return redirect('/groups/login')
    request.session.flush()
    return redirect('/groups/login')

import json
from captcha.models import CaptchaStore
from captcha.helpers import captcha_image_url
def refresh_captcha(request):
    hashkey = CaptchaStore.generate_key()
    image_url = captcha_image_url(hashkey)
    return HttpResponse(json.dumps({'key': hashkey, 'image_url': image_url}), content_type='application/json')

@check_login
def company(request):
    companys = GroupUser.objects.get(id = request.session['user_id']).group.members.all()
    for i in companys:
        i.useradmin = s_models.User.objects.get(ubelongpart=i,issuper=1).username
    return render(request, 'groups/company.html', locals())

def job(request):
    return render(request, 'groups/job.html', locals())

def company_user(request, cid):
    users = s_models.User.objects.filter(usecomp=cid)
    # for user in users:
    #     dump(user)
    return render(request, 'groups/company_user.html', locals())

def company_userdetail(request, uid):
    try:
        user = s_models.User.objects.get(pk=uid)
    except s_models.User.DoesNotExist:
        raise Http404("User does not exist")

    #UserForm.set_usecomp(s_models.Partment.objects.all())
    user_form = UserForm(model_to_dict(user))
    return render(request, 'groups/company_userdetail.html', locals())

def groups_userupdate(request):
    if request.method == 'POST':
        user_form = UserForm(request.POST)
        if user_form.is_valid():
            model_user = s_models.User.objects.filter(pk=user_form.cleaned_data.get('userid'))[0]
            if model_user:
                # model_user.ubelongpart = user_form.cleaned_data.get('ubelongpart')
                # model_user.usecomp = user_form.cleaned_data.get('usecomp')
                # model_user.save()

                newpart = user_form.cleaned_data.get('ubelongpart')
                oldpart = model_user.ubelongpart

                oldpart.aqy = oldpart.aqy.replace(',' + str(model_user.userid) + ',', '')
                oldpart.bmzg = oldpart.bmzg.replace(',' + str(model_user.userid) + ',', '')
                oldpart.bsq = oldpart.bsq.replace(',' + str(model_user.userid) + ',', '')
                oldpart.save()
                part = s_models.Partment.objects.get(partid=newpart.partid)

                if part.iscompany == 1:
                    usecomp = part
                else:
                    usecomp = s_models.Partment.objects.get(partid=part.partlink.split(',')[1])
                model_user.ubelongpart = part
                model_user.usecomp = usecomp
                model_user.save()

                for i in s_models.Group.objects.filter(usecomp=usecomp):
                      i.users.remove(model_user)
                groupobj = s_models.Group.objects.filter(usecomp=usecomp, grouptype=3).first()
                groupobj.users.add(model_user)
            else:
                message = '没有发现该用户'
        return render(request, 'groups/company_userchange.html', locals())
    else:
        return redirect('/groups/company/')

def company_userchange_page(request, uid):
    try:
        user = s_models.User.objects.get(pk=uid)
    except s_models.User.DoesNotExist:
        raise Http404("User does not exist")
    user_form = UserForm(model_to_dict(user))

    return render(request, 'groups/company_userchange.html', locals())

def dump(obj):
    print('\n'.join(['%s:%s' % item for item in obj.__dict__.items()]))


@check_login
def index(req):
    first_day,first_day_of_next_month=gettime()
    group = GroupUser.objects.get(id = req.session['user_id']).group
    companys = group.members.all()
    troublenum = s_models.Trouble.objects.filter(deletemark=1,usecomp__in=companys,fxsj__range=(first_day, first_day_of_next_month)).count()
    observenum = s_models.Observe.objects.filter(deletemark=1,usecomp__in=companys,looktime__range=(first_day, first_day_of_next_month)).count()
    missnum = s_models.Miss.objects.filter(deletemark=1,usecomp__in=companys,misstime__range=(first_day, first_day_of_next_month)).count()
    trainnum = s_models.Train.objects.filter(deletemark=1,usecomp__in=companys,starttime__range=(first_day, first_day_of_next_month)).count()
    companynum = len(companys)
    usernum = s_models.User.objects.filter(deletemark=1,usecomp__in=companys).count()
    return render(req, 'groups/index.html', locals())


def updateposition(req):
    allcompanys = s_models.Partment.objects.filter(deletemark=1,iscompany=1)
    for i in allcompanys:
        address = i.partname
        data = getPosition(address)
        if data['status'] == '1' and int(data['count'])>0:
            i.position = data['geocodes'][0]
            i.save()
        else:
            address = i.partname.replace('公司','').replace('责任','').replace('有限','')
            data = getPosition(address)
            if data['status'] == '1' and int(data['count'])>0:
                i.position = data['geocodes'][0]
                i.save()
    return JsonResponse({"code":1}) 

def getPosition(address):
    url = 'http://restapi.amap.com/v3/geocode/geo'
    par = {'address': address, 'key': '86e0993305a427ac2d0b5371ad97f242'}
    res = requests.get(url, par)
    json_data = json.loads(res.text)
    return json_data

def apipositions(req):
    companys = GroupUser.objects.get(id = req.session['user_id']).group.members.all()
    positions = companys.values('position','partname')
    return JsonResponse({"code":1,"data":list(positions)})
def trouble(request):#隐患排查
    return render(request, 'groups/troublepic.html', locals())
def observe(request):#行为观察
    return render(request, 'groups/observe.html', locals())
def miss(request):#未遂事件
    return render(request, 'groups/miss.html', locals())
def risk(request):#风险管控
    return render(request, 'groups/risk.html', locals())
def train(request):#教育培训
    return render(request, 'groups/train.html', locals())
def exam(request):#在线考试
    return render(request, 'groups/exam.html', locals())
def troubleChart(request):#隐患统计图
    code = request.GET.get('code')
    start = request.GET.get('start')
    end = request.GET.get('end')
    if code=='tbpic':
         companys = GroupUser.objects.get(id = request.session['user_id']).group.members.all()
         troublelist = s_models.Trouble.objects.filter(deletemark=1,usecomp__in=companys).values('usecomp__partid','usecomp__partname').annotate(number = Count('troubleid'))
         if start:
                troublelist = troublelist.filter(fxsj__gte=start)
         if end:
                troublelist = troublelist.filter(fxsj__lte=end)
         return HttpResponse(json.dumps({'code':1,'data':{'troublelist':list(troublelist)}}), content_type='application/json')
def observeChart(request):#行为观察
    code = request.GET.get('code')
    start = request.GET.get('start')
    end = request.GET.get('end')
    if code=='obv':
         companys = GroupUser.objects.get(id = request.session['user_id']).group.members.all()
         observelist = s_models.Observe.objects.filter(deletemark=1,usecomp__in=companys).values('usecomp__partid','usecomp__partname').annotate(number = Count('lookid'))
         if start:
                observelist = observelist.filter(looktime__gte=start)
         if end:
                observelist = observelist.filter(looktime__lte=end)
         return HttpResponse(json.dumps({'code':1,'data':{'observelist':list(observelist)}}), content_type='application/json')
         
def missChart(request):#未遂事件
    code = request.GET.get('code')
    start = request.GET.get('start')
    end = request.GET.get('end')
    if code=='miss':
        
         companys = GroupUser.objects.get(id = request.session['user_id']).group.members.all()
         misslist = s_models.Miss.objects.filter(deletemark=1,usecomp__in=companys).values('usecomp__partid','usecomp__partname').annotate(number = Count('missid'))
         if start:
                misslist = misslist.filter(misstime__gte=start)
         if end:
                misslist = misslist.filter(misstime__lte=end)
         return HttpResponse(json.dumps({'code':1,'data':{'misslist':list(misslist)}}), content_type='application/json')
         
def riskChart(request):#风险管控
    code = request.GET.get('code')
    start = request.GET.get('start')
    end = request.GET.get('end')
    if code=='risk':
         
         companys = GroupUser.objects.get(id = request.session['user_id']).group.members.all()
         risklist = s_models.Risk.objects.filter(usecomp__in=companys).values('usecomp__partid','usecomp__partname').annotate(number = Count('id'))
         if start:
                risklist = risklist.filter(createtime__gte=start)
         if end:
                risklist = risklist.filter(createtime__lte=end)
         return HttpResponse(json.dumps({'code':1,'data':{'risklist':list(risklist)}}), content_type='application/json')
def trainChart(request):#教育培训
    code = request.GET.get('code')
    start = request.GET.get('start')
    end = request.GET.get('end')
    if code=='train':
         companys = GroupUser.objects.get(id = request.session['user_id']).group.members.all()
         trainlist = s_models.Train.objects.filter(usecomp__in=companys).values('usecomp__partid','usecomp__partname').annotate(number = Count('trainid'))
         if start:
                trainlist = trainlist.filter(starttime__gte=start)
         if end:
                trainlist = trainlist.filter(starttime__lte=end)
         return HttpResponse(json.dumps({'code':1,'data':{'trainlist':list(trainlist)}}), content_type='application/json')
                  
def examChart(request):#在线考试
    code = request.GET.get('code')
    start = request.GET.get('start')
    end = request.GET.get('end')
    examjson = []
    if code=='exam':
         companys = GroupUser.objects.get(id = request.session['user_id']).group.members.all()
         
         for i in companys:
             examlist = s_models.ExamTest.objects.filter(usecomps__contains=','+i+',').count()
             if start:
                examlist = examlist.filter(starttime__gte=start)
             if end:
                examlist = examlist.filter(starttime__lte=end)
             examjson.append({'companyName':i.Partment,'number':Partment})
         return HttpResponse(json.dumps({'code':1,'data':examjson}), content_type='application/json')