from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

# Serializers. Defines which fields from an object get to the JSON object
# Also optionally define POST, PATCH methods (create, update)

from rest_framework import serializers
from rowers.models import (
    Workout,Rower,FavoriteChart,VirtualRaceResult,
    VirtualRace,GeoCourse,StandardCollection, CourseStandard,
    GeoCourse, GeoPolygon, GeoPoint,PlannedSession,
    )

from django.core.exceptions import PermissionDenied

import datetime

# Serializers define the API representation.
class RowerSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Rower
        fields = (
            'id',
            'weightcategory',
            'max',
            'rest',
            'ut2',
            'ut1',
            'at',
            'tr',
            'an',
            'hrzones',
            'powerzones',
            'pw_ut2','pw_ut1','pw_at','pw_tr','pw_an',
            'ftp',
            'hrftp',
            'sex',
            'defaulttimezone',
            'getimportantemails',
            'adaptiveclass',
            )

class FavoriteChartSerializer(serializers.ModelSerializer):
    class Meta:
        model = FavoriteChart
        fields = (
            'id',
            'xparam',
            'yparam1',
            'yparam2',
            'plottype',
            'workouttype',
            'reststrokes',
            'user'
            )






class CourseStandardSerializer(serializers.ModelSerializer):

    class Meta:
        model = CourseStandard
        fields = (
            'id',
            'name',
            'coursedistance',
            'coursetime',
            'agemin',
            'agemax',
            'boatclass',
            'boattype',
            'sex',
            'weightclass',
            'adaptiveclass',
            'skillclass',
            'standardcollection',
        )

class StandardCollectionSerializer(serializers.ModelSerializer):
    standards = CourseStandardSerializer(many=True,read_only=True)
    class Meta:
        model = StandardCollection
        fields = (
            'id',
            'name',
            'notes',
            'active',
            'standards'
        )

class ShortEntrySerializer(serializers.ModelSerializer):
    entrycategory = CourseStandardSerializer(read_only=True)
    class Meta:
        model = VirtualRaceResult
        fields = (
            'id',
            'username',
            'teamname',
            'boattype',
            'sex',
            'age',
            'adaptiveclass',
            'skillclass',
            'coursecompleted',
            'distance',
            'duration',
            'points',
            'entrycategory',
        )

class VirtualRaceSerializer(serializers.ModelSerializer):
    coursestandards = StandardCollectionSerializer(read_only=True)
    entries = ShortEntrySerializer(many=True,read_only=True)
    class Meta:
        model = VirtualRace
        fields = (
            'id',
            'name',
            'course',
            'registration_closure',
            'evaluation_closure',
            'start_time',
            'end_time',
            'country',
            'timezone',
            'contact_phone',
            'contact_email',
            'entries',
            'coursestandards',
        )

class PlannedSessionSerializer(serializers.ModelSerializer):
    class Meta:
        model = VirtualRace
        fields = (
            'id',
            'name',
            'comment',
            'startdate',
            'enddate',
            'preferreddate',
            'sessiontype',
            'sessionvalue',
            'sessionunit',
            'sessionmode',
            'course',
            'approximate_distance',
            'approximate_duration',
            #'steps',
            'fitfile'
        )

    def create(self, validated_data): # pragma: no cover
        if self.context['request'].user.is_authenticated:
            r = Rower.objects.get(user=self.context['request'].user)
        else:
            raise PermissionDenied("Not allowed")

        ps = PlannedSession.objects.create(manager=r.user,**validated_data)
        ps.rower.add(r)
        ps.save()
        return ps

class EntrySerializer(serializers.ModelSerializer):
    entrycategory = CourseStandardSerializer(read_only=True)
    race = VirtualRaceSerializer(read_only=True)
    class Meta:
        model = VirtualRaceResult
        fields = (
            'id',
            'teamname',
            'adaptiveclass',
            'skillclass',
            'race',
            'distance',
            'duration',
            'points',
            'boattype',
            'sex',
            'age',
            'entrycategory',
        )

class WorkoutSerializer(serializers.ModelSerializer):
    class Meta:
        model = Workout
        fields = (
            'id',
            'name',
            'date',
            'workouttype',
            'starttime',
            'startdatetime',
            'distance',
            'duration',
            'averagehr',
            'maxhr',
            'notes',
            'summary',
            'boattype',
            'timezone',
            'forceunit',
            'inboard',
            'oarlength',
            'privacy',
            'rankingpiece',
            'trimp',
            'rscore',
            'normp',
            'duplicate',
        )

    def create(self, validated_data): # pragma: no cover
        if self.context['request'].user.is_authenticated:
            r = Rower.objects.get(user=self.context['request'].user)
        else:
            raise PermissionDenied("Not allowed")
        d = validated_data['date']
        t = validated_data['starttime']
        rowdatetime = datetime.datetime(d.year,
                                        d.month,
                                        d.day,
                                        t.hour,
                                        t.minute,
                                        t.second)


        validated_data['startdatetime'] = rowdatetime
        validated_data['user'] = r

        return Workout.objects.create(**validated_data)

    def update(self, instance, validated_data): # pragma: no cover
        d = validated_data['date']
        t = validated_data['starttime']
        rowdatetime = datetime.datetime(d.year,
                                        d.month,
                                        d.day,
                                        t.hour,
                                        t.minute,
                                        t.second)


        instance.name=validated_data['name']
        instance.date=validated_data['date']
        instance.workouttype=validated_data['workouttype']
        instance.duration=validated_data['duration']
        instance.distance=validated_data['distance']
        instance.starttime=validated_data['starttime']
        instance.notes=validated_data['notes']
        instance.summary=validated_data['summary']
        instance.averagehr=validated_data['averagehr']
        instance.maxhr=validated_data['maxhr']
        instance.startdatetime=rowdatetime
        instance.timezone=validated_data['timezone']
        instance.forceunit=validated_data['forceunit']
        instance.inboard=validated_data['inboard']
        instance.oarlength=validated_data['oarlength']
        instance.privacy=validated_data['privacy']
        instance.rankingpiece=validated_data['rankingpiece']

        instance.save()
        return instance

# This is just a fake one for URL registration purposes
class StrokeDataSerializer(serializers.Serializer):
    workoutid = serializers.IntegerField
    strokedata = serializers.JSONField

    def create(self, workoutid, strokedata): # pragma: no cover
        """
        Create and enter a new set of stroke data  into the DB
        """

        # do something
        return 1

class GeoPointSerializer(serializers.ModelSerializer):
    class Meta:
        model = GeoPoint
        fields = (
            'id',
            'latitude',
            'longitude',
            'order_in_poly',
        )
        extra_kwargs = {'id': {'read_only': False, 'required': True}}

class GeoPolygonSerializer(serializers.ModelSerializer):
    points = GeoPointSerializer(many=True)
    class Meta:
        model = GeoPolygon
        fields = (
            'id',
            'name',
            'order_in_course',
            'points',
        )
        extra_kwargs = {'id': {'read_only': False, 'required': True}}

class GeoCourseSerializer(serializers.ModelSerializer):
    polygons = GeoPolygonSerializer(many=True)
    class Meta:
        model = GeoCourse
        fields = (
            'id',
            'name',
            'distance',
            'country',
            'notes',
            'polygons',
        )

    def update(self, instance, validated_data): # pragma: no cover
        instance.name = validated_data.get('name',instance.name)
        instance.country = validated_data.get('country',instance.country)
        instance.notes = validated_data.get('notes',instance.notes)
        instance.save()

        polygons = validated_data.get('polygons')
        for polygon in polygons:
            polygon_id = polygon.get('id',None)
            if polygon_id:
                p = GeoPolygon.objects.get(id=polygon_id)
                p.name = polygon.get('name',p.name)
                p.order_in_course = polygon.get('order_in_course',p.order_in_course)
                p.save()

                points = polygon.get('points')

                for point in points:
                    point_id = point.get('id',None)
                    if point_id:
                        pt = GeoPoint.objects.get(id=point_id)
                        pt.latitude = point.get('latitude',pt.latitude)
                        pt.longitude = point.get('longitude',pt.longitude)
                        pt.order_in_poly = point.get('order_in_poly',pt.order_in_poly)
                        pt.save()

        return instance