import graphene
import structlog
from graphene import relay
from rest_framework.exceptions import PermissionDenied

from vbv_lernwelt.course.graphql.types import CourseSessionUserType
from vbv_lernwelt.course.models import CourseSessionUser
from vbv_lernwelt.course_session.graphql.types import (
    CourseSessionAttendanceCourseObjectType,
)
from vbv_lernwelt.course_session.models import CourseSessionAttendanceCourse
from vbv_lernwelt.course_session.services.attendance import (
    AttendanceUserStatus,
    update_attendance_list,
)
from vbv_lernwelt.iam.permissions import has_course_access
from vbv_lernwelt.learnpath.models import CourseProfile

logger = structlog.get_logger(__name__)


class UpdateCourseProfileSuccess(graphene.ObjectType):
    user = graphene.Field(CourseSessionUserType(), required=True)


class UpdateCourseProfileError(graphene.ObjectType):
    message = graphene.String()


class UpdateCourseProfileResult(graphene.Union):
    class Meta:
        types = (
            UpdateCourseProfileError,
            UpdateCourseProfileSuccess,
        )

    @classmethod
    def resolve_type(cls, instance, info):
        if type(instance).__name__ == "UpdateCourseProfileSuccess":
            return UpdateCourseProfileSuccess
        return UpdateCourseProfileError


class AttendanceUserInputType(graphene.InputObjectType):
    user_id = graphene.UUID(required=True)
    status = graphene.Field(
        graphene.Enum.from_enum(AttendanceUserStatus), required=True
    )


class AttendanceCourseUserMutation(graphene.Mutation):
    course_session_attendance_course = graphene.Field(
        CourseSessionAttendanceCourseObjectType
    )

    class Input:
        id = graphene.ID(required=True)
        attendance_user_list = graphene.List(AttendanceUserInputType, required=True)

    @classmethod
    def mutate(
        cls,
        root,
        info,
        id,
        attendance_user_list,
    ):
        attendance_course = CourseSessionAttendanceCourse.objects.get(id=id)

        if not attendance_course or not has_course_access(
            info.context.user,
            attendance_course.course_session.course_id,
        ):
            raise PermissionDenied()

        attendance_course = update_attendance_list(
            attendance_course=attendance_course,
            attendance_user_list=attendance_user_list,
        )

        return AttendanceCourseUserMutation(
            course_session_attendance_course=attendance_course
        )


class CourseSessionProfileMutation(relay.ClientIDMutation):
    class Input:
        course_profile = graphene.String(required=True)
        course_slug = graphene.String(required=True)

    result = UpdateCourseProfileResult()

    @classmethod
    def mutate_and_get_payload(cls, root, info, **input):
        course_profile = input.get("course_profile")
        course_slug = input.get("course_slug")
        user = info.context.user

        try:
            if course_profile == "":
                profile = None
            else:
                profile = CourseProfile.objects.get(code=course_profile)

            # csu = user.coursesessionuser_set.first()
            csu = CourseSessionUser.objects.get(
                course_session__course__slug=course_slug, user=user
            )
            csu.chosen_profile = profile
            csu.save()
            return cls(result=UpdateCourseProfileSuccess(user=csu))
        except CourseProfile.DoesNotExist:
            return cls(result=UpdateCourseProfileError("Course Profile does not exist"))
        except CourseSessionUser.DoesNotExist:
            return cls(
                result=UpdateCourseProfileError("Course Session User does not exist")
            )


class CourseSessionMutation:
    update_course_session_attendance_course_users = AttendanceCourseUserMutation.Field()
    update_course_session_profile = CourseSessionProfileMutation.Field()