from django.shortcuts import render
from django.utils import timesince
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework import status
from admin_panel.models import *
from django.contrib.auth.hashers import make_password, check_password
from rest_framework_simplejwt.tokens import RefreshToken
from admin_panel.authentication import adminauthenticated
import random
from django.conf import settings
from django.template.loader import render_to_string
from django.core import mail
from django.contrib.auth.models import User
from panel_api.models import *
import random
import string
from django.core.mail import send_mail
from django.contrib.auth.hashers import make_password
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from rest_framework import status, permissions
from .models import *
from django.db.models import Count
from django.db.models.functions import TruncMonth
from django.utils.timesince import timesince
# Create your views here.


class AdminRegister(APIView):
	def post(self, request):
		try:
			email = request.data.get("email")
			password = request.data.get("password")

			if not email or not password:
				return Response({"status_message": "Email and password are required"}, status=status.HTTP_400_BAD_REQUEST)

			if User.objects.filter(email=email).exists():
				return Response({"status_message": "User with this email already exists"}, status=status.HTTP_400_BAD_REQUEST)

			user = User.objects.create_user(
				username=email,
				email=email,
				password=password
			)

			super_admin = SuperAdmin.objects.create(
				user=user,
				email=email,
				password=make_password(password)
			)

			refresh = RefreshToken.for_user(user)
			all_data ={
				"access": str(refresh.access_token),
				"refresh": str(refresh),
				"user_id": user.id,
				"email": user.email
			}
			return Response({
				'status_code': status.HTTP_200_OK,
				"status_message": "Admin registered successfully",
				"data":all_data,
			}, status=status.HTTP_201_CREATED)

		except Exception as e:
			return Response({"status_message": f"Registration failed: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


class LoginAdmin(APIView):
	def post(self, request):
		try:
			email = request.data.get("email")
			password = request.data.get("password")

			if not email or not password:
				return Response({"status_message": "Email and password are required"}, status=status.HTTP_400_BAD_REQUEST)
			

			if not email:
				return Response({"status_message":'email is required'},status=status.HTTP_400_BAD_REQUEST)
			if not password:
				return Response({"status_message":'password is required'},status=status.HTTP_400_BAD_REQUEST)
		
			try:
				user = SuperAdmin.objects.get(email=email)
			except SuperAdmin.DoesNotExist:
				return Response({"status_message": "Email not exist"}, status=status.HTTP_401_UNAUTHORIZED)

			if not check_password(password, user.password):
				return Response({"status_message": "Invalid credentials"}, status=status.HTTP_401_UNAUTHORIZED)
			
			refresh = RefreshToken.for_user(user)
			all_data = {
				"email": user.email,
				"access": str(refresh.access_token),
				"refresh": str(refresh),
				"type":"superadmin",
			}
			return Response({
				'status_code': status.HTTP_200_OK,
				"status_message": "Login successful",
				'data':all_data,
			}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({"status_message": f"Login failed: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)



class AdminProfile(APIView):
	def get(self,request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)
			user_obj = User.objects.filter(id=uid).first()

			if not user_obj:
				return Response({'status_message': 'user not found'}, status=status.HTTP_404_NOT_FOUND)

			admin_obj  = SuperAdmin.objects.all().first()
			if not admin_obj:
				return Response({"status_message":'Your account has been Inactive, Please contact to admin.',"email":admin_obj.email},status=status.HTTP_406_NOT_ACCEPTABLE)
			all_data ={
				"email":admin_obj.email,
				"name":admin_obj.name,
				"phone_number":admin_obj.phoneNumber,
				"image":admin_obj.image,
			}
			return Response({'status_code':status.HTTP_200_OK,'status_message':'Fetched Successfully','data':all_data},status=status.HTTP_200_OK)
		except Exception as e:
			return Response({'status_message':str(e)},status=status.HTTP_500_INTERNAL_SERVER_ERROR)

	def post(self, request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)
			
			admin_obj = SuperAdmin.objects.filter(user_id=uid).first()
			if not admin_obj:
				return Response({'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)
			
			name = request.data.get('name')
			phoneNumber = request.data.get('phoneNumber')
			image = request.data.get('image')

			if not name:
				return Response({'status_message': 'name is required'}, status=status.HTTP_400_BAD_REQUEST)
			if not phoneNumber:
				return Response({'status_message': 'phoneNumber is required'}, status=status.HTTP_400_BAD_REQUEST)
			if not image:
				return Response({'status_message': 'image is required'}, status=status.HTTP_400_BAD_REQUEST)
			
			print("MEDIA_ROOT:", settings.MEDIA_ROOT)
			media_root=settings.MEDIA_ROOT
	
			print(media_root,'----------media_root')
			print(image,' ---------------image,')
			admin_obj.name = name
			admin_obj.phoneNumber = phoneNumber
			admin_obj.image = image
			admin_obj.save()

			data = {
				"name": admin_obj.name,
				"email": admin_obj.user.email if admin_obj.user else None,
				"phone_number": admin_obj.phoneNumber,
				"image":admin_obj.image,
				"updated_at": admin_obj.updated_at
			}

			return Response({
				'status_code': status.HTTP_200_OK,
				"status_message": "Admin profile updated successfully",
				'data': data
			})
		except Exception as e:
			return Response({'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


class AdminForgetPassword(APIView):
	def post(self, request):
		try:
			email = request.data.get('email', '').strip().lower()

			if not email:
				return Response({"status_message": "Email is required"}, status=status.HTTP_400_BAD_REQUEST)

			user_obj = User.objects.filter(email=email).first()
			if not user_obj:
				return Response({"status_message": "This email does not exist or is not an admin account."},
								status=status.HTTP_404_NOT_FOUND)

			admin_obj = SuperAdmin.objects.filter(user=user_obj).first()
			if not admin_obj:
				return Response({"status_message": "SuperAdmin profile not found for this user."},
								status=status.HTTP_404_NOT_FOUND)

			otp = random.randint(1000, 9999)

			admin_obj.forgot_password_otp = otp
			admin_obj.save()

			subject = "Admin Password Reset OTP"
			html_message = render_to_string('forget_password_otp.html', {'otp': otp, 'email': email})
			plain_message = f"Your OTP for resetting password is {otp}"
			from_email = settings.EMAIL_HOST_USER

			mail.send_mail(subject, plain_message, from_email, [email], html_message=html_message)

			return Response({
				"status_message": "Password reset OTP has been sent to your email.",
				"email": email
			}, status=status.HTTP_200_OK)

		except Exception as e:
			print(e)
			return Response({"message": f"Error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

class AdminVerifyForgetPasswordOTP(APIView):
	def post(self, request):
		try:
			email = request.data.get('email').strip().lower()
			if not email:
				return Response({
					'status_code': status.HTTP_400_BAD_REQUEST,
					'status_message': 'Email is required'
				}, status=status.HTTP_400_BAD_REQUEST)

			otp = request.data.get('otp')
			if not otp:
				return Response({
					'status_code': status.HTTP_400_BAD_REQUEST,
					'status_message': 'OTP is required'
				}, status=status.HTTP_400_BAD_REQUEST)

			check_email = SuperAdmin.objects.filter(email=email)
			if not check_email.exists():
				return Response({
					'status_code': status.HTTP_404_NOT_FOUND,
					'status_message': 'This email does not exist in our database'
				}, status=status.HTTP_404_NOT_FOUND)

			admin_obj = SuperAdmin.objects.filter(email=email, forgot_password_otp=otp).first()

			if admin_obj:
				return Response({
					'status_code': status.HTTP_200_OK,
					'status_message': 'Successfully Verified'
				}, status=status.HTTP_200_OK)
			else:
				return Response({
					'status_code': status.HTTP_400_BAD_REQUEST,
					'status_message': 'Invalid OTP'
				}, status=status.HTTP_400_BAD_REQUEST)

		except Exception as e:
			return Response({
				'status_code': status.HTTP_500_INTERNAL_SERVER_ERROR,
				'status_message': str(e)
			}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


class AdminPrivacyPolicy(APIView):
	def get(self, request):
		try:

			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)
			user_obj = User.objects.filter(id = uid).first()

			if not user_obj:
				return Response({'status_message': 'user not found'}, status=status.HTTP_404_NOT_FOUND)
			admin_obj = SuperAdmin.objects.filter(user=user_obj).first()
			if not admin_obj:
				return Response({'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)
			

			policy = PrivacyPolicy.objects.all().first()
			if not policy:
				return Response({"status_message": "No Privacy Policy found."}, status=status.HTTP_404_NOT_FOUND)
			all_data ={
				"title": policy.title,
				"content": policy.content,
				"last_updated": policy.updated_at
			}
			return Response({
				'status_code': status.HTTP_200_OK,
				'status_message': 'Fetched Successfuly',
				'data':all_data,
			}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({"status_message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

	def post(self, request):
		try:
			uid = adminauthenticated(request)
			user = User.objects.get(id=uid)
			user_obj = User.objects.filter(id=uid).first()

			if not user_obj:
				return Response({'status_message': 'user not found'}, status=status.HTTP_404_NOT_FOUND)


			content = request.data.get("content")
			if not content:
				return Response({"status_message": "Content is required"}, status=status.HTTP_400_BAD_REQUEST)

			policy = PrivacyPolicy.objects.all().first()
			if policy:
				policy.content = content
				policy.created_by = user
				policy.save()
				message = "Privacy Policy updated successfully."
			else:
				PrivacyPolicy.objects.create(content=content, created_by=user)
				message = "Privacy Policy created successfully."

			return Response({'status_code': status.HTTP_200_OK,"status_message": message}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({"status_message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)



class AdminTermsCondition(APIView):
	def get(self, request):
		try:

			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)
			user_obj = User.objects.filter(id = uid).first()

			if not user_obj:
				return Response({'status_message': 'user not found'}, status=status.HTTP_404_NOT_FOUND)
			admin_obj = SuperAdmin.objects.filter(user=user_obj).first()
			if not admin_obj:
				return Response({'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)
			
			terms = TermsAndConditions.objects.filter().first()
			if not terms:
				return Response({"status_message": "No Terms and Conditions found."}, status=status.HTTP_404_NOT_FOUND)
			
			all_data ={
				"title": terms.title,
				"content": terms.content,
				"last_updated": terms.updated_at
			}
			return Response({
				'status_code': status.HTTP_200_OK,
				'status_message': 'Fetched Successfuly',
				'data':all_data,
			}, status=status.HTTP_200_OK)
		

		except Exception as e:
			return Response({"status_message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

	def post(self, request):
		try:
			uid = adminauthenticated(request)
			user = User.objects.get(id=uid)

			content = request.data.get("content")
			if not content:
				return Response({"status_message": "Content is required"}, status=status.HTTP_400_BAD_REQUEST)

			terms = TermsAndConditions.objects.filter().first()
			if terms:
				terms.content = content
				terms.created_by = user
				terms.save()
				message = "Terms & Conditions updated successfully."
			else:
				TermsAndConditions.objects.create(content=content, created_by=user)
				message = "Terms & Conditions created successfully."

			return Response({'status_code': status.HTTP_200_OK,"status_message": message}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({"status_message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

class AdminUserList(APIView):
	def get(self, request):
		try:
			uid = adminauthenticated(request)
			admin = SuperAdmin.objects.filter(user_id=uid).first()
			if not admin:
				return Response({"status_message": "Unauthorized Access"}, status=status.HTTP_403_FORBIDDEN)

			users = EndUser.objects.all()
			all_Data=[]
			for user_obj in users:
				data = {
				"id": user_obj.id,
				"name": user_obj.name,
				"email": user_obj.email,
				"phone_number": user_obj.phone_number,
				"created_at": user_obj.created_at,
				}
				all_Data.append(data)

			return Response({
				'status_code': status.HTTP_200_OK,
				'status_message': 'Fetched Successfuly',
				"total_users": users.count(),
				"data": all_Data,
			}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({"status_message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

class AdminUserDetails(APIView):
	def get(self, request):
		try:
			uid = adminauthenticated(request)
			admin = SuperAdmin.objects.filter(user_id=uid).first()
			if not admin:
				return Response({"status_message": "Unauthorized Access"}, status=status.HTTP_403_FORBIDDEN)
			user_id = request.GET.get('user_id')
			if not user_id:
				return Response({"status_message": "user_id is required"}, status=status.HTTP_400_BAD_REQUEST)

			user_obj = EndUser.objects.filter(id=user_id).first()
			if not user_obj:
				return Response({"status_message": "User not found"}, status=status.HTTP_404_NOT_FOUND)

			data = {
				"id": user_obj.id,
				"name": getattr(user_obj, 'name', ''),
				"email": getattr(user_obj, 'email', ''),
				"phone_number": getattr(user_obj, 'phone_number', ''),
				"created_at": user_obj.created_at,
			}

			return Response({'status_code': status.HTTP_200_OK,'status_message': 'Fetched Successfuly',"data": data}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({"status_message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

class AdminChangePassword(APIView):
	def post(self, request):
		try:
			email = request.data.get('email', '').strip().lower()
			new_password = request.data.get('new_password')
			confirm_password = request.data.get('confirm_password')

			if not email:
				return Response({
					'status_code': status.HTTP_400_BAD_REQUEST,
					'status_message': 'Email is required'
				}, status=status.HTTP_400_BAD_REQUEST)

			if not new_password or not confirm_password:
				return Response({
					'status_code': status.HTTP_400_BAD_REQUEST,
					'status_message': 'Both password fields are required'
				}, status=status.HTTP_400_BAD_REQUEST)

			if new_password != confirm_password:
				return Response({
					'status_code': status.HTTP_400_BAD_REQUEST,
					'status_message': 'Passwords do not match'
				}, status=status.HTTP_400_BAD_REQUEST)

			admin_obj = SuperAdmin.objects.filter(email=email).first()
			if not admin_obj:
				return Response({
					'status_code': status.HTTP_404_NOT_FOUND,
					'status_message': 'Admin not found'
				}, status=status.HTTP_404_NOT_FOUND)

			admin_obj.password = make_password(new_password)
			admin_obj.forgot_password_otp = None
			admin_obj.save()

			return Response({
				'status_code': status.HTTP_200_OK,
				'status_message': 'Password changed successfully'
			}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({
				'status_code': status.HTTP_500_INTERNAL_SERVER_ERROR,
				'status_message': str(e)
			}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


class AdminCreateUser(APIView):
	def post(self, request):
		try:
			uid = adminauthenticated(request)
			admin = SuperAdmin.objects.filter(user_id=uid).first()
			if not admin:
				return Response({"status_message": "Unauthorized Access"}, status=status.HTTP_403_FORBIDDEN)
			name = request.data.get('name')
			email = request.data.get('email')
			phone_number = request.data.get('phone_number')

			if not name or not email:
				return Response({"status_message": "Name and email are required"}, status=status.HTTP_400_BAD_REQUEST)

			if EndUser.objects.filter(email=email).exists():
				return Response({"status_message": "User with this email already exists"}, status=status.HTTP_400_BAD_REQUEST)

			password = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
			password_hashed = make_password(password)
			user = EndUser.objects.create(
				name=name,
				email=email,
				phone_number=phone_number,
				password=password_hashed,
			)
			# user = EndUser.objects.create(
			#     name=name,
			#     email=email,
			#     phone_number=phone_number,
			#     password=password,
			# )

			subject = "Your Account Has Been Created"
			message = (
				f"Hello {name},\n\n"
				f"Your account has been created by the admin.\n"
				f"Login using the following credentials:\n\n"
				f"Email: {email}\n"
				f"Password: {password}\n\n"
				f"Please change your password after logging in.\n\n"
				f"Best regards,\nAdmin Team"
			)

			send_mail(
				subject,
				message,
				settings.DEFAULT_FROM_EMAIL,
				[email],
				fail_silently=False,
			)

			return Response(
				{
					'status_code': status.HTTP_200_OK,
					"status_message": "User created successfully and password sent to user's email",
					"user_id": user.id,
				},
				status=status.HTTP_201_CREATED
			)

		except Exception as e:
			return Response({"status_message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
		except Exception as e:
			print(e)


class AdminEditUser(APIView):
	def put(self, request, user_id):
		try:
			uid = adminauthenticated(request)
			admin = SuperAdmin.objects.filter(user_id=uid).first()
			if not admin:
				return Response({"status_message": "Unauthorized Access"}, status=status.HTTP_403_FORBIDDEN)

			user = EndUser.objects.filter(id=user_id).first()
			if not user:
				return Response({"status_message": "User not found"}, status=status.HTTP_404_NOT_FOUND)

			name = request.data.get('name')
			email = request.data.get('email')
			phone_number = request.data.get('phone_number')

			if email and EndUser.objects.filter(email=email).exclude(id=user_id).exists():
				return Response({"status_message": "Email already in use by another user"}, status=status.HTTP_400_BAD_REQUEST)

			if name:
				user.name = name
			if email:
				user.email = email
			if phone_number:
				user.phone_number = phone_number

			user.save()

			return Response(
				{'status_code': status.HTTP_200_OK,"status_message": "User updated successfully"},
				status=status.HTTP_200_OK
			)

		except Exception as e:
			return Response({"status_message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
		

class AdminDeleteUser(APIView):
	def delete(self, request, user_id):
		try:
			uid = adminauthenticated(request)
			admin = SuperAdmin.objects.filter(user_id=uid).first()
			if not admin:
				return Response({"status_message": "Unauthorized Access"}, status=status.HTTP_403_FORBIDDEN)

			user = EndUser.objects.filter(id=user_id).first()
			if not user:
				return Response({"status_message": "User not found"}, status=status.HTTP_404_NOT_FOUND)

			user.delete()

			return Response({'status_code': status.HTTP_200_OK,"status_message": "User deleted successfully"}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({"status_message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


class AddAdminProjectModules(APIView):
	def post(self, request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)

			admin = SuperAdmin.objects.filter(user_id=uid).first()
			if not admin:
				return Response({"status_message": "Unauthorized Access"}, status=status.HTTP_403_FORBIDDEN)

			required_fields = [
				'deliverabes_list', 'format_specs', 'resolution_aspect_ratio',
				'notes_spec_req', 'initial_bid_budget', 'deposite_percentage',
				'deposite_value', 'payment_structure', 'producer',
				'executive_producer_supervisor', 'start_date', 'end_date',
				'key_milestones', 'project_title', 'client_name',
				'project_type', 'client_initials'
			]

			missing_fields = [field for field in required_fields if not request.data.get(field)]
			if missing_fields:
				return Response(
					{'status_message': f'Missing required fields: {", ".join(missing_fields)}'},
					status=status.HTTP_400_BAD_REQUEST
				)

			project_data = ProjectModule.objects.create(
				deliverabes_list=request.data.get('deliverabes_list'),
				format_specs=request.data.get('format_specs'),
				resolution_aspect_ratio=request.data.get('resolution_aspect_ratio'),
				notes_spec_req=request.data.get('notes_spec_req'),
				initial_bid_budget=request.data.get('initial_bid_budget'),
				deposite_percentage=request.data.get('deposite_percentage'),
				deposite_value=request.data.get('deposite_value'),
				payment_structure=request.data.get('payment_structure'),
				producer=request.data.get('producer'),
				executive_producer_supervisor=request.data.get('executive_producer_supervisor'),
				start_date=request.data.get('start_date'),
				end_date=request.data.get('end_date'),
				key_milestones=request.data.get('key_milestones'),
				project_title=request.data.get('project_title'),
				client_name=request.data.get('client_name'),
				project_type=request.data.get('project_type'),
				client_initials=request.data.get('client_initials')
			)

			return Response({'status_code': status.HTTP_200_OK,'status_message': 'Project module created successfully'}, status=status.HTTP_201_CREATED)

		except Exception as e:
			print("Error:", e)
			return Response({'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
	
	

	def get(self, request, pk=None):
		"""Get single project detail or paginated list of all projects"""
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)
			admin = SuperAdmin.objects.filter(user_id=uid).first()
			if not admin:
				return Response({"status_message": "Unauthorized Access"}, status=status.HTTP_403_FORBIDDEN)
			if pk:
				# Single project detail view
				project = ProjectModule.objects.filter(id=pk).first()
				if not project:
					return Response({'status_message': 'Project not found'}, status=status.HTTP_404_NOT_FOUND)
				


				project_data = {
					'id': project.id,
					'project_title': project.project_title,
					'client_name': project.client_name,
					'client_initials': project.client_initials,
					'project_type': project.project_type,
					'deliverabes_list': project.deliverabes_list,
					'format_specs': project.format_specs,
					'resolution_aspect_ratio': project.resolution_aspect_ratio,
					'notes_spec_req': project.notes_spec_req,
					'initial_bid_budget': project.initial_bid_budget,
					'deposite_percentage': project.deposite_percentage,
					'deposite_value': project.deposite_value,
					'payment_structure': project.payment_structure,
					'producer': project.producer,
					'executive_producer_supervisor': project.executive_producer_supervisor,
					'start_date': project.start_date,
					'end_date': project.end_date,
					'key_milestones': project.key_milestones,
					'is_archived':project.is_archived,
					'is_favorite': Favorites.objects.filter(admin=admin, project=project).exists(),
					'project_status': project.project_status if project.project_status else None,

					'created_at': project.created_at if hasattr(project, 'created_at') else None,
				}
				return Response({'status_code': status.HTTP_200_OK,'status_message': 'Fetched Successfully','data': project_data}, status=status.HTTP_200_OK)

			projects = ProjectModule.objects.all().order_by('-id')

			try:
				page_number = int(request.GET.get('page', 1))
				page_size = int(request.GET.get('page_size', 10))
			except ValueError:
				page_number = 1
				page_size = 10

			paginator = Paginator(projects, page_size)

			try:
				page_obj = paginator.page(page_number)
			except EmptyPage:
				return Response({
					'total_projects': paginator.count,
					'total_pages': paginator.num_pages,
					'current_page': page_number,
					'page_size': page_size,
					'projects': []
				}, status=status.HTTP_200_OK)


			project_list = [
				{
					'id': project.id,
					'project_title': project.project_title,
					'client_name': project.client_name,
					'client_initials': project.client_initials,
					'project_type': project.project_type,
					'deliverabes_list': project.deliverabes_list,
					'format_specs': project.format_specs,
					'resolution_aspect_ratio': project.resolution_aspect_ratio,
					'notes_spec_req': project.notes_spec_req,
					'initial_bid_budget': project.initial_bid_budget,
					'deposite_percentage': project.deposite_percentage,
					'deposite_value': project.deposite_value,
					'payment_structure': project.payment_structure,
					'producer': project.producer,
					'executive_producer_supervisor': project.executive_producer_supervisor,
					'start_date': project.start_date,
					'end_date': project.end_date,
					'key_milestones': project.key_milestones,
					'is_archived':project.is_archived,
					'is_favorite': Favorites.objects.filter(admin=admin, project=project).exists(),
					'project_status': project.project_status if project.project_status else None,

					'created_at': project.created_at if hasattr(project, 'created_at') else None,
				}
				for project in page_obj.object_list
			]

			return Response({
				'total_projects': paginator.count,
				'total_pages': paginator.num_pages,
				'current_page': page_obj.number,
				'page_size': int(page_size),
				'projects': project_list
			}, status=status.HTTP_200_OK)

		except Exception as e:
			print("Error:", e)
			return Response({'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)



	def put(self, request, pk):
		"""Update an existing project module"""
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)
			admin = SuperAdmin.objects.filter(user_id=uid).first()
			if not admin:
				return Response({"status_message": "Unauthorized Access"}, status=status.HTTP_403_FORBIDDEN)
			project = ProjectModule.objects.filter(id=pk).first()
			if not project:
				return Response({'status_message': 'Project not found'}, status=status.HTTP_404_NOT_FOUND)

			updatable_fields = [
				'deliverabes_list', 'format_specs', 'resolution_aspect_ratio',
				'notes_spec_req', 'initial_bid_budget', 'deposite_percentage',
				'deposite_value', 'payment_structure', 'producer',
				'executive_producer_supervisor', 'start_date', 'end_date',
				'key_milestones', 'project_title', 'client_name',
				'project_type', 'client_initials'
			]

			for field in updatable_fields:
				if field in request.data:
					setattr(project, field, request.data.get(field))

			project.save()
			return Response({'status_code': status.HTTP_200_OK,'status_message': 'Project module updated successfully'}, status=status.HTTP_200_OK)

		except Exception as e:
			print("Error:", e)
			return Response({'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


	def delete(self, request, pk):
		"""Delete a project module"""
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_code': status.HTTP_401_UNAUTHORIZED,'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)
			admin = SuperAdmin.objects.filter(user_id=uid).first()
			if not admin:
				return Response({"status_message": "Unauthorized Access"}, status=status.HTTP_403_FORBIDDEN)
			project = ProjectModule.objects.filter(id=pk).first()
			if not project:
				return Response({'status_code': status.HTTP_404_NOT_FOUND,'status_message': 'Project not found'}, status=status.HTTP_404_NOT_FOUND)

			project.delete()
			return Response({'status_code': status.HTTP_200_OK,'status_message': 'Project module deleted successfully'}, status=status.HTTP_200_OK)

		except Exception as e:
			print("Error:", e)
			return Response({'status_code': status.HTTP_200_OK,'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


class getAdminNotifications(APIView):
	def get(self, request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_code': status.HTTP_401_UNAUTHORIZED,'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)

			admin_obj = SuperAdmin.objects.filter(id=uid).first()
			if not admin_obj:
				return Response({'status_code': status.HTTP_404_NOT_FOUND,'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)

			notify_obj = AdminNotifications.objects.filter(id=admin_obj.id)
			all_Data = []
			for notify in notify_obj:
				all_data = {
					'id': notify.id,
					'message': notify.message,
					'is_read': notify.is_read,
					'type': notify.type,
					'start_date': timesince(notify.start_date) + ' ago',
				}
				all_Data.append(all_data)

			return Response({'status_code': status.HTTP_200_OK, 'status_message': 'Fetched Successfully', 'data': all_Data},status=status.HTTP_200_OK)
		except Exception as e:
			return Response({'status_code': status.HTTP_500_INTERNAL_SERVER_ERROR, 'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


class deleteAdminNotifications(APIView):
	def post(self, request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_code': status.HTTP_401_UNAUTHORIZED,'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)

			admin_obj = SuperAdmin.objects.filter(id=uid).first()
			if not admin_obj:
				return Response({'status_code': status.HTTP_404_NOT_FOUND,'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)

			notification_id = request.data.get('notification_id')
			if not notification_id:
				return Response({'status_code': status.HTTP_404_NOT_FOUND,'status_message': 'notification_id is required'}, status=status.HTTP_404_NOT_FOUND)

			not_obj = AdminNotifications.objects.filter(id=notification_id).first()
			if not_obj:
				not_obj.delete()
				return Response({'status_code': status.HTTP_200_OK,'status_code': status.HTTP_200_OK, 'status_message': 'Deleted Successfully'})
			else:
				return Response({'status_code': status.HTTP_404_NOT_FOUND,'status_message': 'Notification not found'}, status=status.HTTP_404_NOT_FOUND)

		except Exception as e:
			return Response({'status_code': status.HTTP_500_INTERNAL_SERVER_ERROR, 'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)



class ArchiveProjectAdmin(APIView):
	def post(self, request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_code': status.HTTP_401_UNAUTHORIZED,'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)

			admin_obj = SuperAdmin.objects.filter(id=uid).first()
			if not admin_obj:
				return Response({'status_code': status.HTTP_404_NOT_FOUND,'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)
			project_id = request.data.get("project_id")
			if not project_id:
				return Response({'status_code': status.HTTP_400_BAD_REQUEST, "status_message": "project_id is required"}, status=status.HTTP_400_BAD_REQUEST)
			try:
				project = ProjectModule.objects.get(id=project_id)
				project.is_archived = True
				project.save()
				return Response({'status_code': status.HTTP_200_OK, "status_message": "Project archived successfully"}, status=status.HTTP_200_OK)
			except ProjectModule.DoesNotExist:
				return Response({"status_code": status.HTTP_404_NOT_FOUND, "status_message": "Project not found"}, status=status.HTTP_404_NOT_FOUND)
			except Exception as e:
				return Response({"status_code": status.HTTP_404_NOT_FOUND, "status_message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
			
		except Exception as e:
			return Response({'status_code': status.HTTP_500_INTERNAL_SERVER_ERROR, 'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)



class favorite(APIView):
	def post(self, request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)

			admin_obj = SuperAdmin.objects.filter(id=uid).first()
			if not admin_obj:
				return Response({'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)

			project_id = request.data.get('project_id')
			if not project_id:
				return Response({'status_message': 'project_id is required'}, status=status.HTTP_400_BAD_REQUEST)

			project = ProjectModule.objects.filter(id=project_id).first()
			if not project:
				return Response({'status_message': 'Project not found'}, status=status.HTTP_404_NOT_FOUND)
			

			if Favorites.objects.filter(admin=admin_obj, project=project).exists():
				return Response({'status_message': 'Project already in favorites'}, status=status.HTTP_400_BAD_REQUEST)

			Favorites.objects.create(admin=admin_obj, project=project)
			return Response({'status_code': status.HTTP_200_OK, 'status_message': 'Project added to favorites'}, status=status.HTTP_201_CREATED)

		except Exception as e:
			return Response({'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
		
	def get(self, request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)

			admin_obj = SuperAdmin.objects.filter(id=uid).first()
			if not admin_obj:
				return Response({'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)

			favoritess = Favorites.objects.filter(admin=admin_obj).order_by('-created_at')

			data = []
			for fav in favoritess:
				project = fav.project
				if project:
					data.append({
						'favorite_id': fav.id,
						'project_id': project.id,
						'project_title': project.project_title,
						'client_name': project.client_name,
						'project_type': project.project_type,
						'created_at': fav.created_at.strftime("%Y-%m-%d %H:%M:%S")
					})

			return Response({'favorites': data}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
		

class RemoveFavoriteProject(APIView):
	def post(self, request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)

			admin_obj = SuperAdmin.objects.filter(id=uid).first()
			if not admin_obj:
				return Response({'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)

			project_id = request.data.get('project_id')
			if not project_id:
				return Response({'status_message': 'project_id is required'}, status=status.HTTP_400_BAD_REQUEST)

			project = ProjectModule.objects.filter(id=project_id).first()
			if not project:
				return Response({'status_message': 'Project not found'}, status=status.HTTP_404_NOT_FOUND)

			favorite = Favorites.objects.filter(admin=admin_obj, project=project).first()

			if favorite:
				favorite.delete()
				return Response({'status_code': status.HTTP_200_OK, 'status_message': 'Project removed from favorites'}, status=status.HTTP_200_OK)
			else:
				return Response({'message': 'Project is not in favorites'}, status=status.HTTP_400_BAD_REQUEST)

		except Exception as e:
			return Response({'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


class favoriteListing(APIView):

	def get(self, request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)

			admin_obj = SuperAdmin.objects.filter(id=uid).first()
			if not admin_obj:
				return Response({'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)

			favoritess = Favorites.objects.filter(admin=admin_obj).select_related('project').order_by('-created_at')

			data = []
			for fav in favoritess:
				project = fav.project
				data.append({
					'favorite_id': fav.id,
					'project_id': project.id,
					'project_title': project.project_title,
					'client_name': project.client_name,
					'project_type': project.project_type,
					'project_status':project.project_status,
					'project_title': project.project_title,
					'client_name': project.client_name,
					'project_type': project.project_type,
					'project_status': project.project_status,
					'deliverabes_list': project.deliverabes_list,
					'format_specs': project.format_specs,
					'resolution_aspect_ratio': project.resolution_aspect_ratio,
					'notes_spec_req': project.notes_spec_req,
					'initial_bid_budget': project.initial_bid_budget,
					'deposite_percentage': project.deposite_percentage,
					'deposite_value': project.deposite_value,
					'payment_structure': project.payment_structure,
					'producer': project.producer,
					'executive_producer_supervisor': project.executive_producer_supervisor,
					'start_date': project.start_date,
					'end_date': project.end_date,
					'key_milestones': project.key_milestones,
					'client_initials': project.client_initials,
					'is_archived': project.is_archived,
					'created_at': fav.created_at.strftime("%Y-%m-%d %H:%M:%S"),
				})

			return Response({'status_code': status.HTTP_200_OK,'favorites': data}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

class UpdateAdminprojectStatus(APIView):
	
	def post(self, request, project_id=None):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({'status_message': str(e)}, status=status.HTTP_401_UNAUTHORIZED)

			admin_obj = SuperAdmin.objects.filter(id=uid).first()
			if not admin_obj:
				return Response({'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)

			if not project_id:
				return Response({'status_message': 'project_id is required'}, status=status.HTTP_400_BAD_REQUEST)

			project = ProjectModule.objects.filter(id=project_id).first()
			if not project:
				return Response({'status_message': 'Project not found'}, status=status.HTTP_404_NOT_FOUND)

			new_project_status = request.data.get('project_status')
			if not new_project_status:
				return Response({'message': 'project_status is required'}, status=status.HTTP_400_BAD_REQUEST)


			project.project_status = new_project_status
			project.save()

			return Response({
				'message': f"Project status updated to '{new_project_status}'",
				'project_id': project.id,
				'project_status': project.project_status,
				'user_id': project.user.id if project.user else None,
				'user_status': project.user.status if project.user else None
			}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
		


class dashboard(APIView):
	def get(self, request):
		try:
			try:
				uid = adminauthenticated(request)
			except Exception as e:
				return Response({"status_message": str(e)}, status=status.HTTP_401_UNAUTHORIZED)

			admin_obj = SuperAdmin.objects.filter(id=uid).first()
			if not admin_obj:
				return Response({'status_message': 'Admin not found'}, status=status.HTTP_404_NOT_FOUND)
	
			status_counts = {
				"Pending":ProjectModule.objects.filter(project_status="Pending").count(),
				"Inquiry": ProjectModule.objects.filter(project_status="Inquiry").count(),
				"Bid": ProjectModule.objects.filter(project_status="Bid").count(),
				"Approved": ProjectModule.objects.filter(project_status="Approved").count(),
				"Delivered": ProjectModule.objects.filter(project_status="Delivered").count(),
				"Archived": ProjectModule.objects.filter(project_status="Archived").count(),
			}
			status_counts['Total_Projects'] = sum(status_counts.values())
			status_counts['Total_Users'] = ProjectModule.objects.values('user_id').distinct().count()
			projects_per_month = {
				entry['month'].strftime('%b %Y'): entry['total']
				for entry in ProjectModule.objects
					.annotate(month=TruncMonth('created_at'))  
					.values('month')
					.annotate(total=Count('id'))              
					.order_by('month')
			}

			status_counts['Projects_Per_Month'] = projects_per_month


			return Response({
				
				'status_message': 'success',
				'data': status_counts
			}, status=status.HTTP_200_OK)

		except Exception as e:
			return Response({'status_message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)