#-*- coding: utf-8 -*-
from django.shortcuts import render
from django.shortcuts import get_object_or_404, render
from django.http import HttpResponseRedirect, HttpResponse
from django.urls import reverse
from backoffice.models import *
from backoffice.forms import TokenForm
from django.shortcuts import redirect, render_to_response
from django.views import View
from django.template import RequestContext
from django.shortcuts import render
import facebook
from datetime import datetime,timedelta
from django.utils import timezone
import dateutil.parser as dateparser
from django.contrib.gis.geos import Point
from django.template.defaultfilters import slugify
from dateutil.parser import parse
import logging,json
# Get an instance of a logger
logger = logging.getLogger('django')

def robust_decode(bs):
    if bs is None:
        return ''
    if type(bs) is dict:
        logger.info("on a dico !!!!")
        for element in bs:
            logger.info("Element %s"%element)
    else:
        return bs
        """
        cr = None
        try:
            cr = bs.decode('utf8')
        except Exception as e:
            logger.info("==== decode UTF8 erreur pour %s essaye en latin1 car %s"%(u''+bs,e))
            cr =  bs.decode('latin1')
        logger.info("--On renvoi %s" % (cr))
        return cr
"""



def processData(eventList):
    errors=  []
    try:
        if eventList:
            for eventFB in eventList:
                try:
                    facebookId = robust_decode(eventFB['id'])
                    logger.info("Event %s %s"%(facebookId,robust_decode(eventFB['name'])))
                    eventExit = Event.objects.filter(facebookId=facebookId)
                    if len(eventExit) > 0:
                        # pass
                        logger.info("----- %s deja existant %s" % (robust_decode(eventFB['name']),facebookId))

                        eventUpdate = eventExit[0]
                        modify=False
                        startTime = eventFB['start_time']
                        if "end_time" in eventFB:
                            endTime = eventFB['end_time']
                        else:
                            endTime = startTime
                        dateParseDeb = parse(startTime, ignoretz=False)
                        dateParseFin = parse(endTime, ignoretz=False)
                        eventUpdate.startDateEvent = dateParseDeb
                        eventUpdate.endDateEvent = dateParseFin
                        today = datetime.now().date()
                        if 'event_times' in eventFB:
                            eventUpdate.jsonDate = json.dumps(eventFB["event_times"])
                            eventTimes = eventFB['event_times']

                            logger.info("--- Event multiple date" )
                            nextDateToSet = None
                            for theDateInfo in eventTimes:
                                if 'ticket_uri' in theDateInfo:
                                    eventUpdate.ticketUrl = theDateInfo["ticket_uri"]
                                dateDeb = theDateInfo["start_time"]
                                dateFin = theDateInfo["end_time"]
                                parseDateDeb = dateparser.parse(dateDeb)
                                parseEndDate = dateparser.parse(dateFin)
                                if today <= parseDateDeb.date():
                                    logger.info("--set nextDateToSet %s" % parseDateDeb)
                                    nextDateToSet = parseDateDeb
                            logger.info("--Ok trouve prochaine date %s" % nextDateToSet)
                            eventUpdate.dateEvent = nextDateToSet
                        if "description" in eventFB:
                            if facebookId=="406054329946496":
                                pass
                            else:
                                eventUpdate.description = eventFB['description']
                            modify=True
                        if "cover" in eventFB:
                            cover = eventFB['cover']
                            if "source" in cover:
                                eventUpdate.picture = cover['source']
                                modify = True
                        if modify:
                            eventUpdate.save()
                    else:
                        # evenement
                        #logger.info("------ Pas dejà ---")
                        startTime = eventFB['start_time']
                        if "end_time" in eventFB:
                            endTime = eventFB['end_time']
                        else:
                            endTime = startTime
                        dateParseDeb = parse(startTime, ignoretz=False)
                        dateParseFin = parse(endTime, ignoretz=False)
                        timeDuration = dateParseFin - dateParseDeb
                        tempsTotal = timeDuration.total_seconds() / 86400
                        #logger.info("On a endTime")
                        today = datetime.now().date()
                        todayFull = timezone.now()

                        startDate = dateparser.parse(startTime)
                        endDate = dateparser.parse(endTime)
                        logger.info("---- Today %s start Time %s et endDate %s et todayFull %s" % (today, startDate,endDate,todayFull))
                        #si fini on ne fait rien
                        if endDate<todayFull:
                            logger.info("--- événement fini")
                        else:
                            try:
                                # Futur
                                event = Event()
                                event.startDateEvent = dateParseDeb
                                event.endDateEvent = dateParseFin
                                event.dateEvent = startDate

                                if tempsTotal > 1:
                                    event.requireAttention = True
                                    event.isDaily = True
                                event.name = robust_decode(eventFB['name'])
                                logger.info("Recup name event %s" % eventFB)
                                if 'event_times' in eventFB:
                                    event.jsonDate = json.dumps(eventFB["event_times"])
                                    eventTimes = eventFB['event_times']

                                    logger.info("--- Event multiple date %s" % eventTimes)
                                    nextDateToSet = None
                                    for theDateInfo in eventTimes:
                                        if 'ticket_uri' in theDateInfo:
                                            event.ticketUrl = theDateInfo["ticket_uri"]
                                        dateDeb = theDateInfo["start_time"]
                                        dateFin = theDateInfo["end_time"]
                                        parseDateDeb = dateparser.parse(dateDeb)
                                        parseEndDate = dateparser.parse(dateFin)
                                        if today <= parseDateDeb.date():
                                            logger.info("--set nextDateToSet %s" % parseDateDeb)
                                            nextDateToSet = parseDateDeb
                                    logger.info("--Ok trouve prochaine date %s" % nextDateToSet)
                                    event.dateEvent = nextDateToSet
                                if "description" in eventFB:
                                    event.description = eventFB['description']
                                    # logger.info("REcup description event %s" % event.description)
                                else:
                                    event.description = ''
                                if "cover" in eventFB:
                                    cover = eventFB['cover']
                                    if "source" in cover:
                                        event.picture = cover['source']
                                    else:
                                        logger.info("cover %s" % cover)
                                        event.picture = ''
                                else:
                                    event.picture = ''
                                city = None
                                latitude = None
                                name = None
                                placeName = None
                                if "place" in eventFB:
                                    if "name" in eventFB["place"]:
                                        placeName = robust_decode(eventFB['place']['name'])
                                    if "location" in eventFB['place']:
                                        city = robust_decode(eventFB['place']['location']['city'])
                                        if "street" in eventFB['place']['location']:
                                            event.street = robust_decode(eventFB['place']['location']['street'])
                                        else:
                                            event.street = ''
                                        if "zip" in eventFB['place']['location']:
                                            event.zipCode = robust_decode(eventFB['place']['location']['zip'])
                                        else:
                                            event.zipCode = ''
                                        event.pageFacebook = 'https://www.facebook.com/events/' + facebookId
                                        if "latitude" in eventFB['place']['location']:
                                            latitude = robust_decode(eventFB['place']['location']['latitude'])
                                            longitude = robust_decode(eventFB['place']['location']['longitude'])
                                    else:
                                        if "name" in eventFB["place"]:
                                            name = eventFB["place"]["name"]
                                            if "Paris" in name:
                                                city = "Paris"
                                            elif "Barcelona" in name:
                                                city = "Barcelona"
                                            elif "Madrid" in name:
                                                city = "Madrid"
                                            elif "London" in name:
                                                city = "London"
                                            elif "Sitges" in name:
                                                city = "Sitges"
                                            elif "Berlin" in name:
                                                city = "Berlin"
                                            elif "Brussels" in name:
                                                city = "Brussels"
                                            elif "LE DEPOT" in name:
                                                city = "Paris"
                                            else:
                                                city = "Inconnu"
                                                logger.error("Pas de location %s Name %s" % (eventFB, name))
                                                errors.append("Pas de location %s Name %s" % (eventFB, name))
                                        else:
                                            logger.error("Pas de location et pas de name")
                                            errors.append("Pas de location et pas de name")
                                    """
                                        exemple
                                        u'place': {u'name': u'Place de la R\xe9publique, 75011 Paris, France'}, 
                                        """

                                else:
                                    placeName = ''
                                if latitude is None:
                                    longitude = 0
                                    latitude = 0

                                if not city:
                                    city = "Inconnu"

                                if city:
                                    if city == 'Barcelona':
                                        event.refTown = Town.objects.get(pk=1)
                                    elif city == 'Berlin' or city == u'Neukölln':
                                        event.refTown = Town.objects.get(pk=2)
                                    elif city == 'London':
                                        event.refTown = Town.objects.get(pk=3)
                                    elif city == 'Paris':
                                        event.refTown = Town.objects.get(pk=4)
                                    elif city == 'Sitges':
                                        event.refTown = Town.objects.get(pk=5)
                                    elif city == 'Brussels':
                                        event.refTown = Town.objects.get(pk=6)
                                    elif city == 'Madrid':
                                        event.refTown = Town.objects.get(pk=8)
                                    elif city == "Inconnu":
                                        event.refTown = Town.objects.get(pk=9)
                                    else:
                                        event.refTown = Town.objects.get(pk=9)

                                    event.refEventCategory = EventCategory.objects.get(pk=1)  # Clubbing
                                    # Recuperation place si existe
                                    try:
                                        logger.info("===== On recupere place %s"%placeName)
                                        places = Place.objects.filter(refTown=event.refTown, name__iexact=placeName)
                                        if places:
                                            place = places[0]
                                            event.refPlace = place
                                            logger.info("Place %s" % place)
                                        else:
                                            logger.info("Pas de place trouvee")
                                            event.refPlace = Place.objects.get(pk=0)  # Unknown
                                    except Exception as e:
                                        logger.error(e)
                                        event.refPlace = Place.objects.get(pk=0)
                                    # Create slug
                                    event.slug = slugify(event.name)
                                    # create point
                                    pnt = Point(longitude, latitude)
                                    event.location = pnt
                                    event.placeName = placeName
                                    event.valid = True
                                    # ville ?
                                    # event.refTown = place.refTown
                                    # event.refPlace = None
                                    event.facebookId = eventFB['id']
                                    event.jsonStripe = json.dumps(eventFB)
                                    event.save()
                                    logger.info("--- Importe ID %s event [%s] startDate [%s]" % (
                                        u'' + event.facebookId, u'' + event.name, event.dateEvent))
                                else:
                                    errors.append("Non importe car ville inconnue %s" % (eventFB))
                                    logger.info("---- Non importe car ville inconnue %s name %s" % (eventFB, name))
                            except Exception as e:
                                logger.error("!!!!!!!! ERREUR EVENT %s" % eventFB)
                                logger.error(e)
                                errors.append("Exception %s" % (e))
                except Exception as e:
                    logger.error("!!!!!!!! ERREUR EVENT %s" % eventFB)
                    logger.error(e)
                    errors.append("Exception %s" % (e))
        else:
            logger.info("Event list vide [%s]" % (eventList))
    except Exception as e:
        logger.error("!!!!!!!!!!!!!!!!! ERREUR %s"%eventFB)
        logger.error(e)
        errors.append("Exception %s pour event %s" % (e,eventFB))
    logger.info("on renvoi errors list %s"%errors)
    return errors


def extractEvent(token,facebookId):
    listErrors = []
    graph = facebook.GraphAPI(access_token=token, version="5.0")
    try:
        logger.info("========= NOUVEL IMPORT V5 ===========")
        queryPath = "/"+facebookId
        errors = None
        event = graph.request(queryPath)
        array = []
        array.append(event)
        errors = processData(array)
        for error in errors:
            listErrors.append(error)

        return listErrors
    except Exception as e:
        logger.error(e)
        listErrors.append(e)
def extractMyEvents(token):
    listErrors= []
    graph = facebook.GraphAPI(access_token=token, version="5.0")
    try:
        logger.info("========= NOUVEL IMPORT V5 ===========")
        queryPath = "/me/events/?fields=cover,name,description,place,start_time,end_time"
        yaNext = True
        errors = None
        while yaNext:
                try:
                    events = graph.request(queryPath)
                    logger.info("queryPath %s"%queryPath)
                    eventList = events['data']
                    errors  = processData(eventList)
                    for error in errors:
                        listErrors.append(error)
                    paging = events['paging']
                    if paging:
                        if 'next' in paging:
                            next = paging['next']
                            logger.info("on recoit next %s" % next)
                            oneShortUrl = next.replace('https://graph.facebook.com/v3.2/', '')
                            shortUrl = oneShortUrl.replace('https://graph.facebook.com/v3.2/', '')
                            logger.info("on query next %s" % shortUrl)
                            queryPath = shortUrl
                        else:
                            logger.info("Fin du paging")
                            yaNext=False
                    else:
                        logger.info("Fin du paging")
                        yaNext = False
                except Exception as e:
                    logger.error("QueryPath %s"%queryPath)
                    logger.error(e)
        return listErrors

    except Exception as e:
        logger.error(e)
        listErrors.append(e)

def CustomBatchView(request):
    if request.method == 'POST':
        form = TokenForm(request.POST)
        if form.is_valid():
            logger.info("Ok on a recu token %s" % form.data['token'])
            token = form.data['token']
            if form.data["facebookId"]:
                listErrors = extractEvent(token,form.data["facebookId"])
            else:
                listErrors = extractMyEvents(token)
            return render_to_response('batch/eventresultat.html',{'list':listErrors})

    else:
        form = TokenForm()
    return render(request, 'batch/import.html', {'form': form})

def cgu(request):
    return  render(request, 'batch/cgu.html', {})