import os
import time
import logging
#from specs import doRender
from util.sessions import Session
from google.appengine.ext import db
from google.appengine.ext import webapp
from google.appengine.api import memcache
from google.appengine.ext.webapp import util
from google.appengine.ext.webapp import template

# the next line defines the ammount of comments per page
comments_times = 10

# A Model for a Review
class Review(db.Model):
    reviewid = db.IntegerProperty()
    account = db.StringProperty()
    title = db.StringProperty()
    content = db.TextProperty()
    added = db.DateTimeProperty(auto_now=True)
    checked = db.BooleanProperty()

# A Model for a User
class User(db.Model):
    account = db.StringProperty()
    password = db.StringProperty()
    name = db.StringProperty()

class Review_Index(db.Model):
    review_list = db.StringListProperty()


# doRender
def doRender(handler, tname='base.html', values={}):
    handler.session = Session()
    temp = os.path.join(os.path.dirname(__file__), 'templates/' + tname)
    if not os.path.isfile(temp):
        return False
    # Make a copy of the dictionary and add the path
    newval = dict(values)
    newval['path'] = handler.request.path
    newval['current_time'] = time.ctime()

    realname = ''
    try:
        realname = memcache.get("realname")
    except:
        pass
    if realname == None:
        try:
            results = db.GqlQuery("SELECT * FROM User WHERE account = '"+(handler.session['username'])+"'")
            realname = results.get()
            realname = realname.name
            memcache.add("realname", realname, 3000)
        except:
            realname = 'An error occured'


    # next statement contains list on pages to display the large title image
    if newval['path'] in ['/', '/about']:
        newval['title_image'] = 'yes'

    # next statement contains list of pages not to display login link
    if newval['path'] not in ['/']:
        newval['login_link'] = 'yes'
    # next line permanently diables login link
    newval['login_link'] = 'yes'
    newval['realname'] = realname
    try:
        newval['username']  = handler.session['username']
    except:
        pass
    try:
        newval['style'] = handler.request.get('style')
    except:
        pass
    outstr = template.render(temp, newval)
    handler.response.out.write(outstr)
    return True

def get_content(reviewid=1):
    result = 'Yup'
    content = {}
    result = {'a':'Something went wrong; sorry'}
    try:
        result = memcache.get(str(reviewid))
        if result != None:
            logging.debug('Memcache get successful, result was: '+str(result))
    except:
        logging.debug('"content" memcache get excepted')
        pass
    if result == None:
        #try:
        results = db.GqlQuery("SELECT * FROM Review WHERE reviewid = "+str(reviewid))
        content = results.get()
            # the next four lines transfer information from the datastore into local variables
        result = {'reviewid':content.reviewid,
                   'account':content.account,
                   'content':content.content,
                   'added':content.added,
                   'title':content.title,
                  'checked':content.checked}
        logging.debug('Result equaled none; got the following from datastore: '+str(result))
        memcache.add(str(reviewid), result, 3000)
        logging.debug('Adding current reviewid + details to memcache: '+str(reviewid))
        #except:
         #   result = 'An error occured'
    return result


def get_reviewlist():
    results = None
    review_list = []
    review_list = ['Something went wrong; sorry']
    try:
        review_list = memcache.get('review_list')
        if result != None:
            logging.debug('Memcache get successful, result was: '+str(result))
    except:
        logging.debug('"review_list" memcache get excepted')
        pass
    if review_list == None:
        #try:
        results = db.GqlQuery("SELECT * FROM Review_Index")
        content = results.get()
            # the next four lines transfer information from the datastore into local variables
        review_list = content.review_list
        logging.debug('Result equaled none; got the following from datastore: '+str(review_list))
        memcache.add('review_list', review_list, 3000)
        logging.debug('Adding current Review_Index to memcache')
        #except:
         #   result = 'An error occured'
    return review_list


#def create_reviewid():
 #   current_arg = 1
  #  tort_review_list = list()
   # review_list = get_reviewlist()
    #for chunk in review_list:
     #   tort_review_list.append(chunk)
    #while 1:
     #   if str(current_arg) not in tort_review_list:
      #      logging.debug('reviewid generated: '+str(current_arg))
       #     return 0
        #else:
         #   current_arg =+ 1
    #return current_arg

def create_reviewid():
    current_arg = 1
    tort_reviewlist = list()
    review_list = get_reviewlist()
    for chunk in review_list:
        tort_reviewlist.append(chunk)
    yup = 1
    while yup == 1:
        if current_arg in tort_reviewlist:
            current_arg = current_arg + 1
        else:
            yup = 0
            logging.debug('reviewid generated: '+str(current_arg))
            return current_arg


class ReviewsHandler(webapp.RequestHandler):
    def get(self):
        self.session = Session()
        message = self.request.get('message')
        temp = []
        if (self.request.get('a')) != 'true':
            review_list = get_reviewlist()
            for chunk in range(len(review_list)):
                temp.append(get_content(review_list[chunk]))
            if message != None:
                template_values = {
                    'page_title':'MRLS Inc. - Reviews',
                    'content_section':temp,
                    'message':message
                    }
            else:
                template_values = {
                               'page_title':'MRLS Inc. - Reviews',
                               'content_section':temp
                               }
            doRender(self, 'reviews.html', template_values)
        else:
            review_to_display = self.request.get('r')
            cur_content = get_content(review_to_display)
            doRender(self, 'singlereview.html', {'page_title':('MRLS Inc. - '+cur_content['title']),
                                                 'content_section':cur_content})


class Add(webapp.RequestHandler):
    def get(self):
        self.session = Session()


        try:
            self.username = self.session['username']
            doRender(self,
                 'addreview.html',
                 {'page_title':'MRLS Inc. - Add a Review'})
        except KeyError:
            doRender(self,
                     'addreview.html',
                     {'page_title':'MRLS Inc. - Add a Review',
                      'error_message':'Please note: you need to <a href="/login">Login</a> to post a review'})
    def post(self):
        self.session = Session()
        error_message = ''
        name = self.request.get('name')
        content = self.request.get('content')
        cur_reviewid = create_reviewid()
        cur_review = Review(reviewid=cur_reviewid, account=(self.session['username']), title=name, content=content, checked=False)
        cur_review.put()
        memcache.flush_all()



  #      cur_reviewlist = cur_reviewlist.review_list
        cur_reviewlist = get_reviewlist()

        # delete all current Review_Index's
        query = Review_Index.all()
        entries = query.fetch(1000)
        db.delete(entries)

        cur_reviewlist.append(cur_reviewid)
        review_list = Review_Index(review_list=(cur_reviewlist))
        review_list.put()

        memcache.flush_all()
        memcache.add('review_list', useful_temp, 3000)
        if error_message == None:
            doRender(self,
                     'addreview.html',
                     {'page_title':'MRLS Inc. -  Add a Review',
                      'error_message':error_message})
        else:
            self.redirect('/reviews?message=Your+GameWatch+review+was+posted')

class Execute(webapp.RequestHandler):
    def get(self):
        try:
            doRender(self, 'execute.html', {'review_index':(get_reviewlist())})
        except:
            doRender(self, 'execute.html')
    def post(self):
        typer = self.request.get('type')
        if typer == 'Review':
            cur_reviewid = self.request.get('reviewid')
            cur_account = self.request.get('account')
            cur_title = self.request.get('title')
            cur_content = self.request.get('content')
            cur_checked = self.request.get('checked')
            cur_review = Review(reviewid=int(cur_reviewid), account=cur_account, title=cur_title, content=cur_content, checked=bool(cur_checked))
            cur_review.put()
            memcache.flush_all()

        if typer == 'Review_Index':
            # delete all current Review_Index's
            query = Review_Index.all()
            entries = query.fetch(1000)
            db.delete(entries)
            cur_review_index = self.request.get('review_list')
            cur_index = list(cur_review_index)
            review_list = Review_Index(review_list=cur_index)
            review_list.put()
            memcache.flush_all()
        if typer == 'flush':
            memcache.flush_all()

        doRender(self, 'execute.html')