from rest_framework import serializers
from .models import *
from exercise.serializers import ExerciseSerializer
from registered_user.serializers import GetRegisteredUserSerializer
from muscle.models import ExerciseMuscle
from equipment.models import WorkoutEquipment
from video.models import Video
from video.serializers import VideoSerializer

class WorkoutExerciseSerializer(serializers.ModelSerializer):
    exercise = ExerciseSerializer(read_only=True)
    duration_audio = serializers.ReadOnlyField()
    weight_audio = serializers.ReadOnlyField()

    class Meta:
        model = WorkoutExercise
        fields = ('workout', 'exercise','weight','reps','duration','duration_audio','weight_audio', 'created_at',)

class CompleteWorkoutSerializer(serializers.ModelSerializer):
    class Meta:
        model = CompletedWorkout
        exclude = ['registered_user']

    def create(self, validated_data):
        registered_user_id = self.context.get("registered_user")
        registered_user = RegisteredUser.objects.get(id=registered_user_id)
        completed_workout = CompletedWorkout.objects.create(
            registered_user=registered_user,
            workout=validated_data['workout'],
            difficulty=validated_data['difficulty'],
            total_time=validated_data['total_time'],
            workout_start_time=validated_data['workout_start_time'],
            notes=validated_data['notes'],
            total_calories=validated_data['total_calories']
        )
        completed_workout.save()
        return completed_workout

class WorkoutSerializer(serializers.ModelSerializer):
    # exercise = WorkoutExerciseSerializer(source='workout_exercise_workout', many=True)
    registered_user = GetRegisteredUserSerializer(many=False, read_only=True)
    muscles = serializers.SerializerMethodField()
    equipment = serializers.SerializerMethodField()
    exercise_count = serializers.SerializerMethodField()

    class Meta:
        model = Workout
        fields = '__all__'
        # depth = 1
    
    def get_muscles(self, obj): 
        exercises = WorkoutExercise.objects.filter(workout=obj).values_list('exercise__id')
        muscles_names = ExerciseMuscle.objects.filter(exercise__id__in=exercises).values_list('muscle__name', flat=True)
        return list(set(muscles_names))
    
    def get_equipment(self, obj): 
        exercises = WorkoutExercise.objects.filter(workout=obj).values_list('exercise__id')
        equipment_names = WorkoutEquipment.objects.filter(exercise__id__in=exercises).values_list('equipment__name', flat=True)
        return list(set(equipment_names))
    
    def get_exercise_count(self, obj): 
        return WorkoutExercise.objects.filter(workout=obj).count()

class WorkoutDetailSerializer(serializers.ModelSerializer):
    exercises = serializers.SerializerMethodField()
    registered_user = serializers.SerializerMethodField()
    male_videos = serializers.SerializerMethodField()
    female_videos = serializers.SerializerMethodField()
    both_videos = serializers.SerializerMethodField()

    class Meta:
        model = Workout
        fields = ('id', 'name', 'description', 'exercises', 'registered_user', 'male_videos', 'female_videos', 'both_videos')
        depth = 1
   
    def get_exercises(self, obj): 
        objs = WorkoutExercise.objects.filter(workout=obj).order_by('created_at')
        data = WorkoutExerciseSerializer(objs, many=True).data
        return data
    
    def get_registered_user(self, obj):
        objs = RegisteredUser.objects.get(pk=obj.registered_user.pk)
        data = GetRegisteredUserSerializer(objs, many=False).data
        return data
    
    def get_male_videos(self, obj):
        data = Video.objects.filter(gender=1).values_list('video_file', flat=True)
        return data
    
    def get_female_videos(self, obj):
        data = Video.objects.filter(gender=2).values_list('video_file', flat=True)
        return data
    
    def get_both_videos(self, obj):
        data = Video.objects.filter(gender=3).values_list('video_file', flat=True)
        return data

class GetCompleteWorkoutSerializer(serializers.ModelSerializer):
    workout = WorkoutSerializer(many=False, read_only=True)

    class Meta:
        model = CompletedWorkout
        exclude = ['registered_user']

class POSTCompleteWorkoutSerializer(serializers.ModelSerializer):
    class Meta:
        model = Workout
        exclude = ['registered_user']

class PlannedWorkoutSerializer(serializers.ModelSerializer):
    workout = POSTCompleteWorkoutSerializer(many=False, read_only=True)
    class Meta:
        model = PlannedWorkout
        exclude = ['registered_user']
        depth = 1

class POSTPlannedWorkoutSerializer(serializers.ModelSerializer):
    class Meta:
        model = PlannedWorkout
        exclude = ['registered_user']
        
    def create(self, validated_data):
            print(validated_data)
            registered_user_id = self.context.get("registered_user")
            registered_user = RegisteredUser.objects.get(id=registered_user_id)
            planned_workout = PlannedWorkout.objects.create(
                registered_user=registered_user,
                workout=validated_data['workout'],
                on_date=validated_data['on_date']
            )
            planned_workout.save()
            return planned_workout