import json, logging, uuid, datetime, time

from django.db import transaction

from django.contrib.auth import get_user_model

from django.conf import settings

from django.utils import six

from django.core.exceptions import ValidationError

from renkanmanager import settings as renkan_settings

from renkanmanager.models import Renkan, Workspace, Revision

from rest_framework import serializers

logger = logging.getLogger(__name__)

RENKAN_USER_DISPLAY_FIELD = renkan_settings.RENKAN_USER_DISPLAY_FIELD

class RenkanSerializer(serializers.Serializer):

    id = serializers.ReadOnlyField(source="renkan_guid")

    current_revision_id = serializers.SlugRelatedField(source="current_revision", slug_field="revision_guid", read_only=True)

    workspace_id = serializers.SlugRelatedField(source="workspace", slug_field="workspace_guid", queryset=Workspace.objects, required=False)

    source_revision_id = serializers.SlugRelatedField(source="source_revision", slug_field="revision_guid", queryset=Revision.objects, required=False)

    revision_count = serializers.ReadOnlyField()

    created_by = serializers.SlugRelatedField(source="creator", slug_field=RENKAN_USER_DISPLAY_FIELD, read_only=True)

    last_updated_by = serializers.SerializerMethodField("get_current_revision_last_updator")

    title = serializers.CharField(required=False, allow_blank=True)

    content = serializers.JSONField(required=False)

    creation_date = serializers.ReadOnlyField()

    modification_date = serializers.SerializerMethodField()

    def __init__(self, instance=None, data=serializers.empty, **kwargs):

        self.validation_timestamp = kwargs.pop('validation_timestamp', None)

        super(RenkanSerializer, self).__init__(instance, data, **kwargs)

    def get_current_revision_last_updator(self, renkan):

        last_updator = renkan.current_revision.last_updated_by

        if last_updator:

            return getattr(last_updator, RENKAN_USER_DISPLAY_FIELD)

        else:

            return ''

    def get_modification_date(self, renkan):

        return renkan.current_revision.modification_date

    @transaction.atomic

    def create(self, validated_data):

        """

            Method to create a new Renkan (and its first revision)

        """

        creator = validated_data.get('creator')

        workspace_obj = validated_data.get('workspace', None)

        source_revision_obj = validated_data.get('source_revision', None)

        try:

            return Renkan.objects.create_renkan(

                creator=creator,

                title=validated_data.get('title', ''),

                content=validated_data.get('content', ''),

                workspace=workspace_obj,

                source_revision=source_revision_obj

            )

        except ValidationError as ve:

            raise serializers.ValidationError(ve.args[0])

    @transaction.atomic

    def update(self, renkan, validated_data):

        """

            Method to update a Renkan object. Creates a new revision if needed

        """

        updator = validated_data.get('updator')

        create_new_revision = validated_data.get("create_new_revision", False)

        title = validated_data.get('title', renkan.current_revision.title)

        content = validated_data.get('content', '')

        if not content:

            content = renkan.current_revision.content

        if title != json.loads(content).get("title", ""):

            content_dict = json.loads(content)

            content_dict["title"] = title

            content = json.dumps(content_dict)

        try:

            renkan.save_renkan(updator=updator, timestamp=self.validation_timestamp, title=title, content=content, create_new_revision=create_new_revision)

        except ValidationError as ve:

            raise serializers.ValidationError(str(ve.args[0]))

        # FORCE Renkan reload.

        # TODO: How to avoid the reload ???

        return Renkan.objects.select_related('current_revision').get(id=renkan.id)

    def validate_workspace_id(self, value):

        if self.instance is not None:

            raise serializers.ValidationError("You cannot update workspace_guid")

        return value

    def validate_source_revision_id(self, value):

        if self.instance is not None:

            raise serializers.ValidationError("You cannot update source_revision_guid")

        return value

    def validate_content(self, value):

        try:

            loaded_json = json.loads(value)

        except ValueError:

            raise serializers.ValidationError("Content format is not a JSON-serializable")

        if (not "nodes" in loaded_json):

            raise serializers.ValidationError("Content requires a 'nodes' entry")

        if (not "edges" in loaded_json):

            raise serializers.ValidationError("Content requires a 'edges' entry")

        if (not "views" in loaded_json):

            raise serializers.ValidationError("Content requires a 'views' entry")

        return value

    def validate(self, data):

        if self.instance:

            validation_timestamp = self.validation_timestamp or data.get('content', {}).get('updated')

            if not validation_timestamp:

                raise serializers.ValidationError("No validation timestamp and no content json to extract it from")

            validation_timestamp = dateparse.parse_datetime(validation_timestamp) if isinstance(validation_timestamp, six.string_types) else validation_timestamp

            if validation_timestamp != self.instance.current_revision.modification_date:

                raise serializers.ValidationError("Invalid timestamp was provided")

        return data

class RevisionSerializer(serializers.Serializer):

    id = serializers.ReadOnlyField(source="revision_guid")

    parent_renkan_id = serializers.SlugRelatedField(source="parent_renkan", slug_field='renkan_guid', read_only=True)

    workspace_id = serializers.SerializerMethodField("get_related_workspace_guid")

    title = serializers.ReadOnlyField()

    content = serializers.JSONField(read_only=True)

    renkan_created_by = serializers.SerializerMethodField("get_related_renkan_creator")

    renkan_creation_date = serializers.SerializerMethodField("get_related_renkan_creation_date")

    revision_created_by = serializers.SlugRelatedField(source="creator", slug_field=RENKAN_USER_DISPLAY_FIELD, read_only=True)

    revision_last_updated_by = serializers.SlugRelatedField(source="last_updated_by", slug_field=RENKAN_USER_DISPLAY_FIELD, read_only=True)

    revision_modification_date = serializers.ReadOnlyField(source="modification_date")

    def get_related_workspace_guid(self, revision):

        if revision.parent_renkan.workspace:

            return revision.parent_renkan.workspace.workspace_guid

        else:

            return ''

    def get_related_renkan_creator(self, revision):

        return getattr(revision.parent_renkan.creator, RENKAN_USER_DISPLAY_FIELD)

    def get_related_renkan_creation_date(self, revision):

        return revision.parent_renkan.creation_date

class WorkspaceSerializer(serializers.Serializer):

    id = serializers.ReadOnlyField(source="workspace_guid")

    workspace_created_by = serializers.SlugRelatedField(source="creator", slug_field=RENKAN_USER_DISPLAY_FIELD, read_only=True)

    creation_date = serializers.ReadOnlyField()

    renkan_count = serializers.ReadOnlyField()

    title = serializers.CharField()

    def create(self, validated_data):

        creator = validated_data.get('creator')

        title = validated_data.get('title', '')

        workspace = Workspace.objects.create(creator=creator, title=title)

        workspace.save()

        return workspace

    def update(self, workspace, validated_data):

        workspace.title = validated_data.get('title', '')

        workspace.save()

        return workspace