# Python imports

import doctest

import logging

import os

import traceback

import random

import StringIO

import sys

import json

import time

import sandbox

import re

from matplotlib.pyplot import imread

from numpy import alltrue

from django.contrib.auth.models import User 

from testappproj.testapp.models import *

from django.http import HttpResponse

from django import http

from django import shortcuts

from django.template import Context ,RequestContext

from django.template.loader import get_template

# Local imports

from forms import *

import models

from helpers import bulkuploader as pykataupload

from datetime import date

from django.contrib.auth.decorators import permission_required

from models import Problem

from django.contrib.auth.decorators import login_required 

from models import Score 

from django.utils.datastructures import MultiValueDictKeyError

def respond(request, user,template, params=None):

  """Helper to render a response, passing standard stuff to the response.

  Args:

    request: The request object.

    user: The User object representing the current user; or None if nobody

      is logged in.

    template: The template name; '.html' is appended automatically.

    params: A dict giving the template parameters; modified in-place.

  Returns:

    Whatever render_to_response(template, params) returns.

  Raises:

    Whatever render_to_response(template, params) raises.

  """

  if params is None:

     params = {}

  if user:

    params['user'] = user

    params['sign_out'] = 1

  #   params['is_admin'] = (users.is_current_user_admin())

  else:

    params['sign_in'] = 1

  # if not template.endswith('.html'):

  template += '.html'

  return shortcuts.render_to_response(template, params)

def import_check(user_code):

  no_imports=len(re.findall('import',user_code))

  if (no_imports >= 1):

    return True

  return False

def plot_change_code(user_code):

  user_code=re.sub("show\(\)",'',user_code)

  return user_code

def check_examination_done(f):

        def wrap(request, *args, **kwargs):

                #this check the session if userid key exist, if not it will redirect to login page

                if unicode(request.user)==unicode('amit'):

                  print "hello what the hell"

                  return f(request, *args, **kwargs)

                user= Test_User.objects.get(user=request.user)

                if user.exam_done==True:

                        return HttpResponse("You have given the exam before")

                return f(request, *args, **kwargs)

        return wrap

def execute_plotting_test_cases(user_code , solution_image,problem_id , username):

  solved=False

  if import_check(user_code):

    print "entered"

    return solved,None,True

  user_image_name = str(username)+'_'+str(problem_id)+'_'+str(int(time.time()))+'.png'

  user_code=plot_change_code(user_code)

  code="""from pylab import *

import pylab

%s

figure_conf=pylab.gcf()

figure_conf.set_dpi(80)

  print code

  # create file-like string to capture output

  codeOut = StringIO.StringIO()

  codeErr = StringIO.StringIO()

  print str(codeOut)

  # capture output and errors

  sys.stdout = codeOut

  sys.stderr = codeErr

  sandbox.execute(code)

# restore stdout and stderr

  sys.stdout = sys.__stdout__

  sys.stderr = sys.__stderr__

  errors=codeErr.getvalue()  

  codeOut.close()

  codeErr.close()

  print solved

  return solved,errors,False

def execute_test_cases(code , solution):

  solved=False

  if import_check(code):

    print "entered"

    return solved,None,True

  # create file-like string to capture output

  codeOut = StringIO.StringIO()

  codeErr = StringIO.StringIO()

  # capture output and errors

  sys.stdout = codeOut

  sys.stderr = codeErr

# restore stdout and stderr

  sys.stdout = sys.__stdout__

  sys.stderr = sys.__stderr__

  s = codeOut.getvalue()

  s=unicode(s)

  print s.strip()

  print solution.strip()

  if solution.strip() == s.strip():

    solved =True

  errors=codeErr.getvalue()

  codeOut.close()

  codeErr.close()

  return solved,errors,False

def complete(request):

  print request.user

  user= Test_User.objects.get(user=request.user)

  user.exam_done=True

  user.save()

  return respond(request, request.user ,'submit')

def index(request):

  """ need to change user in the django.contrib way"""

  user = request.user

  return respond(request , user, 'index')

@login_required(function=None, redirect_field_name='next')

@check_examination_done

def problems(request, category=None):

  user = request.user

  entries=[]

  all_sessions=set([element.session  for element in Problem.objects.all()])

  #get problems to solve from each session.

  for session in all_sessions: 

    get_problem=random.Random().choice(Problem.objects.filter(session=session))

    e = dict(problem=get_problem.description,

             username=user.username,

             problem_id=get_problem.id,

             session =get_problem.session

               )

    entries.append(e)

  return respond(request, user, 'problems',{'entries' : entries }  )

@login_required(function=None, redirect_field_name='next')

def code(request, problem_id):

#  print problem_id

  problem = Problem.objects.get(id=int(problem_id))

  if problem is None:

    return http.HttpResponseNotFound('No such problem.')

  print problem.id

  return respond(request, request.user ,'code' ,{'problem' : problem } )

def run(request):

   user = request.user 

   problem_id = request.POST.get('problem_id')

   if problem_id:

     problem = Problem.objects.get(id=int(problem_id))

     if problem is None:

       return http.HttpResponse('There is no problem like this are you sure you solved it')

   user_code = request.POST.get('user_code')

   if  user_code == '':

     return http.HttpResponse('No solution')

   user_code = user_code.replace('\r\n', '\n')

   user_code += '\n\n'

   errors = ''

   print problem.problem_type

   if unicode(problem.problem_type)==unicode('S'):

     solved,errors,import_test= execute_test_cases(user_code,problem.solution)

   else :

     solved,errors,import_test= execute_plotting_test_cases(user_code,problem.solution_image,problem_id,user)

   print solved

   if import_test==True:

     return http.HttpResponse("DO NOT try to import or your exam and account will invalidated")

   if solved==True:

     #user is answering his first question

     try:

       print user.id

       score_for_user= Score.objects.get(user=user)

       score_for_user.total_credits+=problem.credit

       score_for_user.save()

    # user has answered questions previously

     except Score.DoesNotExist:

       score_new_user=user.id

       score_total_credits=problem.credit

       score=Score(user_id=user.id,total_credits=score_total_credits)

       score.save()

   else:

     return http.HttpResponse('Wrong Answer')

   return http.HttpResponse("Right Answer")

@permission_required('testapp.add_problem' , login_url="/code/1234")

def new_edit(request, problem_id=None, internal=False):

  # internal indicates that it is being called internally by uploader

  user = request.user

  if user.is_anonymous() :

    return http.HttpResponseForbidden('You must be an signed in to create edit a problem.')

  if problem_id is None:

    creating_new = True

  else:

    creating_new = False

  if request.method == 'POST':

    form = ProblemForm(request.POST, request.FILES)

  else:

    form = ProblemForm()

  if not request.POST:

    return respond(request, user, 'new_edit_problem', {'form':form, 'problem':None, 'creating':creating_new })

  if form.is_valid():

    try:

      description = form.cleaned_data['Description']

      problem_type=form.cleaned_data['Problem_type']

      solution=form.cleaned_data['Solution']

      session=form.cleaned_data['Session']

      credit=form.cleaned_data['Credit']

   # solution_image=form.cleaned_data['Solution_Image']

      solution_image=request.FILES['Solution_Image']

      author = user.username

      created = date.today()

      modified=date.today()

    # print request.FILES 

    # print "this is solution"+solution

    # print "this is solution_image"+solution_image

      problem=Problem(description=description,problem_type=problem_type,solution_image=solution_image,session=session,author=author,created=created,modified=modified,credit=credit)

    except MultiValueDictKeyError:

      description = form.cleaned_data['Description']

      problem_type=form.cleaned_data['Problem_type']

      solution=form.cleaned_data['Solution']

      session=form.cleaned_data['Session']

      credit=form.cleaned_data['Credit']

   # solution_image=form.cleaned_data['Solution_Image']

      author = user.username

      created = date.today()

      modified=date.today()

      problem=Problem(description=description,problem_type=problem_type,solution=solution,session=session,author=author,created=created,modified=modified,credit=credit)  

    problem.save() 

    print "saved"

  else:

    print "form is valid"

    print form.errors

#  print form.errors

  #  except ValueError, err:

  #    errors['__all__'] = unicode(err)

  if form.errors:

    print "new world"

    return respond(request, user, 'new_edit_problem', 

                         {'form': form, 'problem':problem, 'creating':creating_new,'error':errors})

  # if creating_new:

  #   # if internal:

  #   #   if len(request.POST['user_id'])>0:

  #   #     logging.info(request.POST)

  #   #     problem.author = users.User(request.POST['user_id'])

  #   #   else:

  #   #     problem.author = user

  #   # else: