# Неуспеваемость
def poor_progress_pup(request, selected_group):
    resp_dict = {}
    request_context = request.app_context
    context_institute = request_context['context_institute']
    path_parts = request.path.split('/')
    start_date = end_date = ''

    group = None

    if request.META.has_key('HTTP_REFERER'):
        redirect_url = request.META['HTTP_REFERER']
    if selected_group:
        selected_group = ASIOU_G_Education.objects.get(institute=context_institute, id=selected_group)
        resp_dict['selected_group'] = selected_group.name

    if request.method == 'POST':
        post = request.POST.copy()

        selected_pers_id = []
        subjects_id = []
        selected_form_id = []
        absent_visible = 0
        for key in post:
            if key.find('s_') != -1:
                subjects_id.append(int(key.split('_')[1]))
            elif key.find('p_') != -1:
                selected_pers_id.append(int(key.split('_')[1]))
            elif key == 'check_vizit' and post[key] == 'on':
                absent_visible = 1
            elif key == 'year_start':
                start_year = post[key]
            elif key == 'year_end':
                end_year = post[key]
            elif key.find('form_') != -1:
                selected_form_id.append(int(key.split('_')[1]))

        #            string = post.getlist(key)
        #
        #            if len(string) > 1 and string[0]:
        #                selected_pers_id.append(int(string[0]))

        selected_pers = ASIOU_PE_Person.objects.filter(institute=context_institute, id__in=selected_pers_id)
        resp_dict['selected_pers'] = selected_pers
        form = ASIOU_EP_RID_Export(post)

        if form.is_valid():
            edu_date_start = (date(int(start_year), 9, 1))
            edu_date_end = date(int(end_year), 8, 31)

            if edu_date_start > edu_date_end:
                messages.error(request, u'Не корректно указан год!')
                return HttpResponseRedirect(redirect_url)

            if edu_date_start and edu_date_end and selected_pers:

                ep_grp = []
                ch_groups = ASIOU_G_Education.objects.filter(
                    Q(institute=context_institute),
                    Q(education_year=request_context['edu_year']),
                    Q(type__label='group_10'))

                ep_grp.append(selected_group.id)
                for ch in ch_groups:
                    if selected_group in ch.from_groups.all() and ch not in ep_grp:
                        ep_grp.append(ch.id)

                lessons = ASIOU_EP_Less.objects.filter(Q(date__lte=edu_date_end) & Q(date__gte=edu_date_start),
                                                       Q(institute=context_institute),
                                                       Q(ep_group__group__in=ep_grp),
                                                       Q(ep_group__subject__in=subjects_id)).order_by('date')

                selected_form = ASIOU_EP_Less_Count_Marks.objects.filter(Q(institute=context_institute),
                                                       Q(less__in=lessons),
                                                       Q(type__in=selected_form_id))
                print lessons[0].id


                ep_groups = ASIOU_EP_Group.objects.filter(institute=context_institute, group__in=ep_grp,
                                                          subject__in=subjects_id)


                # Определим систему оценивания для групп
                mark_sys = {}
                for ep_group in ep_groups:
                    mark_sys[ep_group.id] = get_mark_system(context_institute, selected_group, ep_group,
                                                            request_context['edu_year'])

                subjects = ASIOU_I_Subject.objects.filter(institute=context_institute,
                                                          id__in=ep_groups.values('subject__id')).order_by('name')

                pup_list_by_subject = {}
                for s in subjects:
                    persons_by_s = ASIOU_PE_Person.objects.filter(
                        Q(institute=request_context['context_institute']),
                        Q(doc_person__group__in=ep_groups.filter(subject=s).values('group')))
                    pup_list_by_subject[s.id] = list_of(persons_by_s.values('id'), 'id', False, True)
                resp_dict['pup_list_by_subject'] = pup_list_by_subject

                months = []
                less_dates = []
                l_d = []
                if len(lessons):
                    dates = {}
                    i = 1
                    dates_less = {}

                    for l in lessons:
                        if l.date not in l_d:
                            l_d.append(l.date)
                            less_dates.append([l.date, i])
                            i += 1

                        dd = int('%d%02d' % (l.date.year, l.date.month))
                        if dd not in dates_less:
                            dates_less[dd] = []

                        if l.date not in dates_less[dd]:
                            dates_less[dd].append(l.date)

                    months = []
                    for month in dates_less:
                        months.append([dates_less[month][0], len(dates_less[month])])
                    resp_dict['months'] = sorted(months)

                    o_less_count = ASIOU_EP_Less_Count_Marks.objects.filter(less__in=lessons, hidden=0)

                    i = 0
                    id_les_count = []
                    less_to_count = {}

                    for item in o_less_count:
                        i += 1
                        if not item.less.pk in less_to_count:
                            less_to_count[item.less.pk] = []
                            i -= 1

                        less_to_count[item.less.pk].append(item)
                        id_les_count.append(item.pk)

                    resp_dict['type'] = less_to_count
                    resp_dict['dates'] = sorted(dates.items())
                    resp_dict['less_dates'] = less_dates
                    resp_dict['lessons'] = lessons

                    pre_marks = ASIOU_EP_Mark.objects.filter(institute=context_institute,
                                                             less_count_marks__in=id_les_count,
                                                             student__in=selected_pers.values('id'), hidden=0)

                    subj_marks = group_by(
                        pre_marks.values('less_count_marks', 'less_count_marks__less__date', 'mark', 'student',
                                         'less_count_marks__less__ep_group__subject__id',
                                         'less_count_marks__less__ep_group__id',
                                         'less_count_marks__less__ep_group__subject__name'),
                        'less_count_marks__less__ep_group__subject__id')
                    st_subjects = {}
                    p_marks = []

                    if subj_marks:
                        i_s = 1
                        for s in subj_marks:
                            i_s += 1
                            marks = {}
                            for m in subj_marks[s]:
                                num = 0
                                for l in less_dates:
                                    if l[0] == m['less_count_marks__less__date']:
                                        num = l[1]
                                if not num in marks:
                                    marks[num] = {}

                                if not m['student'] in marks[num]:
                                    marks[num][m['student']] = []

                                mark_name = m['mark']
                                p_mark = mark_name
                                marks[num][m['student']].append(p_mark)
                                if not m['student'] in st_subjects:
                                    st_subjects[m['student']] = []
                                if not m['less_count_marks__less__ep_group__subject__id'] in st_subjects.get(
                                        m['student']):
                                    st_subjects[m['student']].append(
                                        m['less_count_marks__less__ep_group__subject__id'])

                                if p_mark == 2:
                                    print '666'
                                    # for s in selected_form:
                                    #     if #двойка совпадает с выбранной ФК
                                    #         #записать ее на печать
                                else:
                                    messages.error(request, u'У данного ученика нет неудовлетворительных отметок')

                            params = {'marks': marks,
                                      'subject': m['less_count_marks__less__ep_group__subject__name']}
                            p_marks.append(params)


                    # resp_dict['p_marks'] = p_marks
                    resp_dict['subjects'] = subjects
                    resp_dict['st_subjects'] = st_subjects
                    resp_dict['selected_form'] = selected_form

                else:
                    messages.error(request, u'За данный период не было проведено ни одного урока!')

    else:
        act_pers_id, no_act_pers_id, act_pers, no_act_pers, count_0 = pup_list_by_group(context_institute, date(
            request_context['edu_year'], 9, 1), datetime.now().date(), selected_group.id, 'with_number')
        p_id = act_pers_id + no_act_pers_id

        if count_0 != len(act_pers):
            act_pers.sort()
        resp_dict['persons'] = act_pers + no_act_pers

        ep_grp = []
        ch_groups = ASIOU_G_Education.objects.filter(
            Q(institute=context_institute),
            Q(education_year=request_context['edu_year']),
            Q(type__label='group_10'))

        ep_grp.append(selected_group.id)
        for ch in ch_groups:
            if selected_group in ch.from_groups.all() and ch not in ep_grp:
                ep_grp.append(ch.id)

        ep_groups = ASIOU_EP_Group.objects.filter(Q(institute=context_institute),
                                                  Q(group__in=ep_grp) | Q(group=selected_group))

        subjects = ASIOU_I_Subject.objects.filter(institute=context_institute,
                                                  id__in=ep_groups.values('subject__id')).order_by('name')

        resp_dict['CHOISE_TYPE_MARKS_OOU'] = CHOISE_TYPE_MARKS_OOU
        resp_dict['subjects'] = subjects

        form = ASIOU_EP_RID_Export()
        resp_dict['form'] = form

        resp_dict['periods_start'] = DatePickerInput().render('date_0', None, attrs={'id': 'id_date_0'})
        resp_dict['periods_end'] = DatePickerInput().render('date_1', None, attrs={'id': 'id_date_1'})
        print '5'

    return render(request, 'current_performance/poor_progress_pup.html', resp_dict)
    # return render_to_response('current_performance/current_marks.html', resp_dict, context_instance=request_context)