from rowers.views.statements import *
from rowers.interactiveplots import sleep
from rowers.plannedsessions import is_session_complete
from rowers.tasks import send_session_stats

from rq import Queue
from redis import Redis
from rq.job import Job

@login_required()
def sleep_view(request):

    script, div = sleep()

    return render(request,
                  "sleep.html",
                  {
                      "the_div": div,
                      "the_script": script, 
                  })

def filmdeaths_view(request):
    script, div = filmdeaths()

    return render(request,
                  "filmdeaths.html",
                  {
                      "the_div": div,
                      "the_script": script, 
                  }
                  )

@login_required()
def download_fit(request, filename=''):
    pss = PlannedSession.objects.filter(fitfile=filename)

    if len(pss) != 1:  # pragma: no cover
        raise Http404("Could not find the required file")

    ps = pss[0]
    owns = False
    if ps.manager == request.user or request.user.rower in ps.rower.all():
        owns = True

    if not owns:  # pragma: no cover
        raise PermissionDenied("You are not allowed to download this file")

    fitfile = ps.fitfile
    try:
        response = HttpResponse(fitfile)
    except FileNotFoundError:
        raise Http404("File not found")

    response['Content-Disposition'] = 'attachment; filename="%s"' % filename  # pragma: no cover
    response['Content-Type'] = 'application/octet-stream'  # pragma: no cover

    return response  # pragma: no cover

@login_required()
def sessions_stats(request):
    if not request.user.is_staff:  # pragma: no cover
        raise PermissionDenied("Not Allowed")

    myqueue(queuelow,
            send_session_stats,
            request.user)

    r = getrower(request.user)
    url = reverse('workouts_view')

    return HttpResponseRedirect(url)



@login_required()
def failed_queue_view(request):
    if not request.user.is_staff:  # pragma: no cover
        raise PermissionDenied("Not Allowed")

    resultslist = []
    for queuename in ['high','default','low']:

        q = Queue(queuename,connection=Redis())
        registry = q.failed_job_registry

        for id in registry.get_job_ids():  # pragma: no cover
            success = 0
            try:
                job = Job.fetch(id,connection=Redis())
                success = 1
            except:
                try:
                    id = id.replace('rq:job','')
                    job = Job.fetch(id,connection=Redis())
                    success = 1
                except:
                    pass

            if success:
                traceback = str(job.exc_info)

                info = {
                    'id': job.id,
                    'started_at': job.started_at,
                    'traceback1': traceback,
                }

                resultslist += [info]


    return render(request,
                  "failed_jobs.html",
                  {
                      'resultslist': resultslist,
                  }
                  )


@login_required()
def failed_queue_empty(request):
    if not request.user.is_staff:  # pragma: no cover
        raise PermissionDenied("Not Allowed")

    for queuename in ['high','default','low']:
        q = Queue(queuename,connection=Redis())
        registry = q.failed_job_registry

        for id in registry.get_job_ids():
            try:
                registry.remove(id,delete_job=True)
            except:
                id = id.replace('rq.job','')
                try:
                    registry.remove(id,delete_job=True)
                except:
                    pass
                
    return HttpResponseRedirect(reverse('failed_queue_view'))


@login_required()
def failed_job_view(request, id=0):  # pragma: no cover
    if not request.user.is_staff:
        raise PermissionDenied("Not Allowed")

    for queuename in ['high','default','low']:
        q = Queue(queuename, connection=Redis())
        registry = q.failed_job_registry
        for tid in registry.get_job_ids():
            if tid == id:
                try:
                    job = Job.fetch(id, connection=Redis())
                    registry.remove(id, delete_job=True)
                except:
                    pass

    return HttpResponseRedirect(reverse('failed_queue_view'))


@login_required()
def errormessage_view(request, errormessage='aap'):  # pragma: no cover
    if (errormessage == '3dsecure'):
        errormessage = '3D Secure Card Verification Error. Please check your card details.'
    messages.error(request, errormessage)

    return JSONResponse({
        "result": 1,
    })


# Shows analysis page
@login_required()
@permission_required('rower.is_coach', fn=get_user_by_userid, raise_exception=True)
def analysis_view(request, userid=0):
    r = getrequestrower(request, userid=userid)
    return render(request,
                  "analysis.html",
                  {
                      'active': 'nav-analysis',
                      'rower': r,
                  }
                  )

# Shows laboratory page


@login_required()
@permission_required('rower.is_coach', fn=get_user_by_userid, raise_exception=True)
def laboratory_view(request, userid=0):
    r = getrequestrower(request, userid=userid)
    return render(request,
                  "laboratory.html",
                  {
                      'active': 'nav-analysis',
                      'rower': r,
                  }
                  )