from django.shortcuts import render
from django.template import loader
from django.http import HttpResponse

# Using render() shortcut
def post_list_with_render(request):
    """Simple post list using render() shortcut"""
    posts = Post.objects.filter(status='published').order_by('-created_at')
    categories = Category.objects.all()
    
    context = {
        'posts': posts,
        'categories': categories,
        'page_title': 'Blog Posts',
        'user': request.user,
    }
    
    return render(request, 'blog/post_list.html', context)

# Equivalent without shortcut (more verbose)
def post_list_without_shortcut(request):
    """Same functionality without using render() shortcut"""
    posts = Post.objects.filter(status='published').order_by('-created_at')
    categories = Category.objects.all()
    
    context = {
        'posts': posts,
        'categories': categories,
        'page_title': 'Blog Posts',
        'user': request.user,
    }
    
    template = loader.get_template('blog/post_list.html')
    html = template.render(context, request)
    return HttpResponse(html)

# render() with conditional template
def responsive_post_list(request):
    """Choose template based on user agent"""
    posts = Post.objects.filter(status='published')
    
    # Simple mobile detection
    user_agent = request.META.get('HTTP_USER_AGENT', '').lower()
    is_mobile = any(device in user_agent for device in ['mobile', 'android', 'iphone'])
    
    template_name = 'blog/post_list_mobile.html' if is_mobile else 'blog/post_list.html'
    
    context = {
        'posts': posts,
        'is_mobile': is_mobile,
    }
    
    return render(request, template_name, context)

# render() with custom content type
def rss_feed_view(request):
    """RSS feed using render() with custom content type"""
    posts = Post.objects.filter(status='published').order_by('-created_at')[:20]
    
    context = {
        'posts': posts,
        'site_url': request.build_absolute_uri('/'),
        'last_build_date': timezone.now(),
    }
    
    return render(request, 'blog/rss_feed.xml', context, content_type='application/rss+xml')

from django.shortcuts import get_object_or_404
from django.http import Http404

# Using get_object_or_404() shortcut
def post_detail_with_shortcut(request, pk):
    """Post detail using get_object_or_404() shortcut"""
    post = get_object_or_404(Post, pk=pk, status='published')
    
    # Get related posts
    related_posts = Post.objects.filter(
        category=post.category,
        status='published'
    ).exclude(pk=post.pk)[:3]
    
    context = {
        'post': post,
        'related_posts': related_posts,
    }
    
    return render(request, 'blog/post_detail.html', context)

# Equivalent without shortcut
def post_detail_without_shortcut(request, pk):
    """Same functionality without using get_object_or_404()"""
    try:
        post = Post.objects.get(pk=pk, status='published')
    except Post.DoesNotExist:
        raise Http404("Post not found")
    
    related_posts = Post.objects.filter(
        category=post.category,
        status='published'
    ).exclude(pk=post.pk)[:3]
    
    context = {
        'post': post,
        'related_posts': related_posts,
    }
    
    return render(request, 'blog/post_detail.html', context)

# get_object_or_404() with complex conditions
def post_by_slug_and_author(request, author_username, post_slug):
    """Get post by slug and author with complex lookup"""
    post = get_object_or_404(
        Post.objects.select_related('author', 'category'),
        slug=post_slug,
        author__username=author_username,
        status='published'
    )
    
    return render(request, 'blog/post_detail.html', {'post': post})

# get_object_or_404() with custom queryset
def user_post_detail(request, pk):
    """Get post that belongs to current user"""
    if not request.user.is_authenticated:
        raise Http404("Post not found")
    
    # Custom queryset - only user's posts
    user_posts = Post.objects.filter(author=request.user)
    post = get_object_or_404(user_posts, pk=pk)
    
    return render(request, 'blog/user_post_detail.html', {'post': post})

# get_object_or_404() with permissions check
def editable_post_detail(request, pk):
    """Get post that user can edit"""
    post = get_object_or_404(Post, pk=pk)
    
    # Check if user can edit this post
    if post.author != request.user and not request.user.is_staff:
        raise Http404("Post not found")
    
    return render(request, 'blog/edit_post.html', {'post': post})

from django.shortcuts import get_list_or_404

def posts_by_category(request, category_slug):
    """Get posts by category, raise 404 if no posts found"""
    category = get_object_or_404(Category, slug=category_slug)
    
    # get_list_or_404 raises Http404 if no posts found
    posts = get_list_or_404(Post, category=category, status='published')
    
    context = {
        'category': category,
        'posts': posts,
    }
    
    return render(request, 'blog/category_posts.html', context)

def posts_by_tag(request, tag_name):
    """Get posts by tag, raise 404 if no posts found"""
    # Using get_list_or_404 with complex lookup
    posts = get_list_or_404(
        Post.objects.filter(tags__name__iexact=tag_name, status='published').distinct()
    )
    
    context = {
        'tag_name': tag_name,
        'posts': posts,
    }
    
    return render(request, 'blog/tag_posts.html', context)

def user_published_posts(request, username):
    """Get user's published posts, raise 404 if none found"""
    user = get_object_or_404(User, username=username, is_active=True)
    
    # Get user's published posts
    posts = get_list_or_404(
        Post.objects.select_related('category'),
        author=user,
        status='published'
    )
    
    context = {
        'author': user,
        'posts': posts,
    }
    
    return render(request, 'blog/author_posts.html', context)

# Alternative approach without get_list_or_404()
def posts_by_category_alternative(request, category_slug):
    """Alternative approach using regular queryset"""
    category = get_object_or_404(Category, slug=category_slug)
    posts = Post.objects.filter(category=category, status='published')
    
    # Check if any posts exist
    if not posts.exists():
        raise Http404("No posts found in this category")
    
    context = {
        'category': category,
        'posts': posts,
    }
    
    return render(request, 'blog/category_posts.html', context)

from django.shortcuts import redirect
from django.urls import reverse
from django.contrib import messages

# Basic redirect patterns
def simple_redirect(request):
    """Simple redirect to another view"""
    return redirect('blog:post_list')

def redirect_with_args(request, post_id):
    """Redirect with URL arguments"""
    return redirect('blog:post_detail', pk=post_id)

def redirect_with_kwargs(request):
    """Redirect with keyword arguments"""
    return redirect('blog:posts_by_year', year=2024)

def permanent_redirect(request):
    """Permanent redirect (301)"""
    return redirect('blog:new_url', permanent=True)

def external_redirect(request):
    """Redirect to external URL"""
    return redirect('https://example.com/external-page/')

# Redirect after form processing
def create_post_redirect(request):
    """Create post with proper redirect handling"""
    if request.method == 'POST':
        form = PostForm(request.POST, request.FILES)
        if form.is_valid():
            post = form.save(commit=False)
            post.author = request.user
            post.save()
            form.save_m2m()
            
            # Success message and redirect
            messages.success(request, f'Post "{post.title}" created successfully!')
            
            # Redirect to the new post
            return redirect('blog:post_detail', pk=post.pk)
        else:
            # Form has errors, don't redirect
            messages.error(request, 'Please correct the errors below.')
    else:
        form = PostForm()
    
    return render(request, 'blog/create_post.html', {'form': form})

# Conditional redirects
def conditional_redirect(request):
    """Redirect based on user status"""
    if not request.user.is_authenticated:
        # Redirect to login with next parameter
        return redirect(f"{reverse('accounts:login')}?next={request.path}")
    
    if request.user.is_staff:
        return redirect('admin:index')
    
    if hasattr(request.user, 'profile') and request.user.profile.is_premium:
        return redirect('premium:dashboard')
    
    # Default redirect
    return redirect('accounts:profile')

# Redirect with query parameters
def search_redirect(request):
    """Redirect with preserved query parameters"""
    query = request.GET.get('q', '')
    category = request.GET.get('category', '')
    
    if not query:
        messages.error(request, 'Please enter a search query.')
        return redirect('blog:post_list')
    
    # Build redirect URL with parameters
    redirect_url = reverse('blog:search_results')
    params = []
    
    if query:
        params.append(f'q={query}')
    if category:
        params.append(f'category={category}')
    
    if params:
        redirect_url += '?' + '&'.join(params)
    
    return redirect(redirect_url)

from django.shortcuts import render, get_object_or_404, redirect
from django.contrib import messages
from django.core.paginator import Paginator
from django.db.models import Q

def render_with_pagination(request, template_name, queryset, per_page=10, context=None):
    """Custom shortcut for paginated rendering"""
    if context is None:
        context = {}
    
    # Get page number from request
    page_number = request.GET.get('page', 1)
    
    # Create paginator
    paginator = Paginator(queryset, per_page)
    page_obj = paginator.get_page(page_number)
    
    # Add pagination context
    context.update({
        'page_obj': page_obj,
        'object_list': page_obj.object_list,
        'paginator': paginator,
        'is_paginated': page_obj.has_other_pages(),
    })
    
    return render(request, template_name, context)

def get_object_or_403(model_or_queryset, user, **kwargs):
    """Get object or raise 403 if user doesn't have permission"""
    from django.core.exceptions import PermissionDenied
    
    obj = get_object_or_404(model_or_queryset, **kwargs)
    
    # Check if user owns the object
    if hasattr(obj, 'user') and obj.user != user:
        raise PermissionDenied("You don't have permission to access this object")
    elif hasattr(obj, 'author') and obj.author != user:
        raise PermissionDenied("You don't have permission to access this object")
    
    return obj

def render_json_or_template(request, template_name, context, json_data=None):
    """Render JSON for AJAX requests, template for regular requests"""
    from django.http import JsonResponse
    
    if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
        # AJAX request - return JSON
        if json_data is None:
            json_data = context
        return JsonResponse(json_data)
    else:
        # Regular request - return template
        return render(request, template_name, context)

def redirect_with_message(request, view_name, message, level=messages.SUCCESS, *args, **kwargs):
    """Redirect with flash message"""
    messages.add_message(request, level, message)
    return redirect(view_name, *args, **kwargs)

# Usage examples
def paginated_post_list(request):
    """Post list with pagination shortcut"""
    posts = Post.objects.filter(status='published').order_by('-created_at')
    
    # Handle search
    query = request.GET.get('q')
    if query:
        posts = posts.filter(Q(title__icontains=query) | Q(content__icontains=query))
    
    context = {
        'query': query,
        'total_posts': posts.count(),
    }
    
    return render_with_pagination(
        request,
        'blog/post_list.html',
        posts,
        per_page=15,
        context=context
    )

def user_post_edit(request, pk):
    """Edit post with permission check"""
    post = get_object_or_403(Post, request.user, pk=pk)
    
    if request.method == 'POST':
        form = PostForm(request.POST, instance=post)
        if form.is_valid():
            form.save()
            return redirect_with_message(
                request,
                'blog:post_detail',
                'Post updated successfully!',
                pk=post.pk
            )
    else:
        form = PostForm(instance=post)
    
    return render(request, 'blog/edit_post.html', {'form': form, 'post': post})

def ajax_post_list(request):
    """Post list that works for both AJAX and regular requests"""
    posts = Post.objects.filter(status='published')[:10]
    
    context = {
        'posts': posts,
    }
    
    json_data = {
        'posts': [
            {
                'id': post.id,
                'title': post.title,
                'url': post.get_absolute_url(),
                'created_at': post.created_at.isoformat(),
            }
            for post in posts
        ]
    }
    
    return render_json_or_template(
        request,
        'blog/post_list.html',
        context,
        json_data
    )

from functools import wraps
from django.shortcuts import get_object_or_404, render

def require_object_owner(model, pk_param='pk', owner_field='user'):
    """Decorator to require object ownership"""
    def decorator(view_func):
        @wraps(view_func)
        def wrapper(request, *args, **kwargs):
            pk = kwargs.get(pk_param)
            obj = get_object_or_404(model, pk=pk)
            
            # Check ownership
            owner = getattr(obj, owner_field)
            if owner != request.user and not request.user.is_staff:
                from django.core.exceptions import PermissionDenied
                raise PermissionDenied("You don't have permission to access this object")
            
            # Add object to kwargs
            kwargs['object'] = obj
            return view_func(request, *args, **kwargs)
        
        return wrapper
    return decorator

def render_to(template_name):
    """Decorator to automatically render view return value"""
    def decorator(view_func):
        @wraps(view_func)
        def wrapper(request, *args, **kwargs):
            result = view_func(request, *args, **kwargs)
            
            # If view returns HttpResponse, return as-is
            if hasattr(result, 'status_code'):
                return result
            
            # If view returns dict, render template
            if isinstance(result, dict):
                return render(request, template_name, result)
            
            # Otherwise, return as-is
            return result
        
        return wrapper
    return decorator

def ajax_required(view_func):
    """Decorator to require AJAX requests"""
    @wraps(view_func)
    def wrapper(request, *args, **kwargs):
        if not request.headers.get('X-Requested-With') == 'XMLHttpRequest':
            from django.http import JsonResponse
            return JsonResponse({'error': 'AJAX request required'}, status=400)
        
        return view_func(request, *args, **kwargs)
    
    return wrapper

# Usage examples
@require_object_owner(Post, owner_field='author')
def edit_post_with_decorator(request, pk, object=None):
    """Edit post with automatic ownership check"""
    post = object  # Injected by decorator
    
    if request.method == 'POST':
        form = PostForm(request.POST, instance=post)
        if form.is_valid():
            form.save()
            return redirect('blog:post_detail', pk=post.pk)
    else:
        form = PostForm(instance=post)
    
    return render(request, 'blog/edit_post.html', {'form': form, 'post': post})

@render_to('blog/post_list.html')
def simple_post_list(request):
    """Post list with automatic template rendering"""
    posts = Post.objects.filter(status='published')
    
    # Return dict - will be automatically rendered
    return {
        'posts': posts,
        'page_title': 'Blog Posts',
    }

@ajax_required
def ajax_post_create(request):
    """AJAX-only post creation"""
    if request.method == 'POST':
        form = PostForm(request.POST)
        if form.is_valid():
            post = form.save(commit=False)
            post.author = request.user
            post.save()
            
            return JsonResponse({
                'success': True,
                'post_id': post.id,
                'redirect_url': post.get_absolute_url()
            })
        else:
            return JsonResponse({
                'success': False,
                'errors': form.errors
            })
    
    return JsonResponse({'error': 'POST method required'}, status=405)

from django.shortcuts import render, get_object_or_404, redirect
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from django.db.models import Q

@login_required
def blog_dashboard(request):
    """User's blog dashboard combining multiple shortcuts"""
    # Get user's posts
    user_posts = Post.objects.filter(author=request.user).order_by('-created_at')
    
    # Handle search within user's posts
    query = request.GET.get('q')
    if query:
        user_posts = user_posts.filter(
            Q(title__icontains=query) | Q(content__icontains=query)
        )
    
    # Get recent comments on user's posts
    recent_comments = Comment.objects.filter(
        post__author=request.user,
        approved=True
    ).select_related('post', 'author').order_by('-created_at')[:5]
    
    # Get draft posts count
    draft_count = Post.objects.filter(author=request.user, status='draft').count()
    
    context = {
        'posts': user_posts[:10],  # Limit to 10 for dashboard
        'recent_comments': recent_comments,
        'draft_count': draft_count,
        'query': query,
        'total_posts': user_posts.count(),
    }
    
    return render(request, 'blog/dashboard.html', context)

def post_detail_with_comments(request, pk):
    """Post detail with comment handling"""
    # Get post or 404
    post = get_object_or_404(
        Post.objects.select_related('author', 'category'),
        pk=pk,
        status='published'
    )
    
    # Get approved comments
    comments = post.comments.filter(approved=True).select_related('author')
    
    # Handle comment submission
    if request.method == 'POST' and request.user.is_authenticated:
        comment_form = CommentForm(request.POST)
        if comment_form.is_valid():
            comment = comment_form.save(commit=False)
            comment.post = post
            comment.author = request.user
            comment.save()
            
            messages.success(request, 'Comment added successfully!')
            return redirect('blog:post_detail', pk=post.pk)
        else:
            messages.error(request, 'Please correct the errors in your comment.')
    else:
        comment_form = CommentForm() if request.user.is_authenticated else None
    
    # Increment view count
    Post.objects.filter(pk=pk).update(views=F('views') + 1)
    
    context = {
        'post': post,
        'comments': comments,
        'comment_form': comment_form,
        'comments_count': comments.count(),
    }
    
    return render(request, 'blog/post_detail.html', context)

@login_required
def bulk_post_actions(request):
    """Handle bulk actions on posts"""
    if request.method == 'POST':
        action = request.POST.get('action')
        post_ids = request.POST.getlist('post_ids')
        
        if not post_ids:
            messages.error(request, 'No posts selected.')
            return redirect('blog:dashboard')
        
        # Get user's posts only
        posts = Post.objects.filter(
            id__in=post_ids,
            author=request.user
        )
        
        if not posts.exists():
            messages.error(request, 'No valid posts selected.')
            return redirect('blog:dashboard')
        
        # Perform bulk action
        if action == 'publish':
            updated = posts.update(status='published')
            messages.success(request, f'{updated} posts published.')
        
        elif action == 'draft':
            updated = posts.update(status='draft')
            messages.success(request, f'{updated} posts moved to draft.')
        
        elif action == 'delete':
            count = posts.count()
            posts.delete()
            messages.success(request, f'{count} posts deleted.')
        
        else:
            messages.error(request, 'Invalid action.')
        
        return redirect('blog:dashboard')
    
    # GET request - show confirmation page
    post_ids = request.GET.getlist('post_ids')
    if not post_ids:
        messages.error(request, 'No posts selected.')
        return redirect('blog:dashboard')
    
    posts = Post.objects.filter(
        id__in=post_ids,
        author=request.user
    )
    
    context = {
        'posts': posts,
        'action': request.GET.get('action', ''),
    }
    
    return render(request, 'blog/bulk_action_confirm.html', context)

def category_posts_with_pagination(request, category_slug):
    """Category posts with search and pagination"""
    # Get category or 404
    category = get_object_or_404(Category, slug=category_slug)
    
    # Get posts in category
    posts = Post.objects.filter(
        category=category,
        status='published'
    ).select_related('author').order_by('-created_at')
    
    # Handle search within category
    query = request.GET.get('q')
    if query:
        posts = posts.filter(
            Q(title__icontains=query) | Q(content__icontains=query)
        )
    
    # Pagination
    from django.core.paginator import Paginator
    paginator = Paginator(posts, 12)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    
    # Get related categories
    related_categories = Category.objects.exclude(id=category.id)[:5]
    
    context = {
        'category': category,
        'posts': page_obj.object_list,
        'page_obj': page_obj,
        'query': query,
        'related_categories': related_categories,
        'total_posts': paginator.count,
    }
    
    return render(request, 'blog/category_posts.html', context)

# tests/test_shortcuts.py
from django.test import TestCase, Client
from django.urls import reverse
from django.contrib.auth.models import User
from blog.models import Post, Category

class ShortcutFunctionTests(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpass'
        )
        self.category = Category.objects.create(
            name='Test Category',
            slug='test-category'
        )
        self.post = Post.objects.create(
            title='Test Post',
            slug='test-post',
            content='Test content',
            author=self.user,
            category=self.category,
            status='published'
        )
    
    def test_render_shortcut(self):
        """Test render() shortcut function"""
        response = self.client.get(reverse('blog:post_list'))
        
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, 'Test Post')
        self.assertIn('posts', response.context)
    
    def test_get_object_or_404_success(self):
        """Test get_object_or_404() with existing object"""
        response = self.client.get(
            reverse('blog:post_detail', kwargs={'pk': self.post.pk})
        )
        
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['post'], self.post)
    
    def test_get_object_or_404_not_found(self):
        """Test get_object_or_404() with non-existent object"""
        response = self.client.get(
            reverse('blog:post_detail', kwargs={'pk': 99999})
        )
        
        self.assertEqual(response.status_code, 404)
    
    def test_get_list_or_404_success(self):
        """Test get_list_or_404() with existing objects"""
        response = self.client.get(
            reverse('blog:category_posts', kwargs={'category_slug': self.category.slug})
        )
        
        self.assertEqual(response.status_code, 200)
        self.assertIn(self.post, response.context['posts'])
    
    def test_get_list_or_404_empty(self):
        """Test get_list_or_404() with no objects"""
        empty_category = Category.objects.create(
            name='Empty Category',
            slug='empty-category'
        )
        
        response = self.client.get(
            reverse('blog:category_posts', kwargs={'category_slug': empty_category.slug})
        )
        
        self.assertEqual(response.status_code, 404)
    
    def test_redirect_shortcut(self):
        """Test redirect() shortcut function"""
        response = self.client.get('/old-url/')  # Assuming this redirects
        
        self.assertEqual(response.status_code, 302)
        self.assertTrue(response.url.startswith('/new-url/'))
    
    def test_custom_shortcut_functions(self):
        """Test custom shortcut functions"""
        self.client.login(username='testuser', password='testpass')
        
        response = self.client.get(reverse('blog:dashboard'))
        
        self.assertEqual(response.status_code, 200)
        self.assertIn('posts', response.context)
        self.assertIn('draft_count', response.context)