# -*- 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
                        if "description" in eventFB:
                            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))

                        # à venir ?
                        if today <= startDate.date() or endDate>=todayFull:
                            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:
                                    eventTimes = eventFB['event_times']
                                    if 'ticket_uri' in eventTimes:
                                        event.ticketUrl=eventTimes["ticket_uri"]
                                    logger.info("--- Event multiple date %s"%eventTimes)
                                    for theDate in eventTimes:
                                        dateDeb = theDate["start_time"]
                                        dateFin = theDate["end_time"]

                                        parseDateDeb = dateparser.parse(dateDeb)
                                        parseEndDate = dateparser.parse(dateFin)
                                        if today<=parseDateDeb.date():
                                            logger.info("--Ok trouve prochaine date %s"%parseDateDeb)
                                            event.dateEvent = parseDateDeb
                                            break
                                        elif parseEndDate.date()>=today:
                                            logger.info("--Ok trouve prochaine date %s" % today)
                                            event.dateEvent = today
                                            break
                                else:
                                    #TODO BUG
                                    if startDate.date()<today:
                                        # sur plusieurs jours
                                        event.dateEvent = today
                                        event.isDaily=True
                                        event.requireAttention = True
                                        logger.info("Event sur plusiers jours on met date today")
                                    else:
                                        event.dateEvent = startDate - timedelta(minutes=60)  # Remove 1hour
                                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")


                                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:
                                        places = Place.objects.filter(refTown=event.refTown,name=placeName)
                                        if places:
                                            place = places[0]
                                            event.refPlace = place
                                        else:
                                            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))
                            # logger.info("Ok on a cree Event %s"%event)
                        #else:
                        #    logger.info("----Dans PASSE  Today %s start Time %s event %s" % (today, startDate.date(),eventFB))
                except Exception as e:
                    logger.error("!!!!!!!! ERREUR LIST 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 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:

            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)
                    shortUrl = next.replace('https://graph.facebook.com/v5.0/', '')
                    shortUrl = next.replace('https://graph.facebook.com/v3.0/', '')
                    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

        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']
            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', {})