from django.shortcuts import render, get_object_or_404, redirect
from django.views.generic import ListView, DetailView
from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decorator
from django.contrib import messages
from .models import Product, Customer, Supplier, Category
from .forms import CustomerForm, SupplierForm, ProductForm, CategoryForm

@method_decorator(login_required, name='dispatch')
class ProductListView(ListView):
    model = Product
    template_name = 'inventory/product_list.html'
    context_object_name = 'products'
    paginate_by = 20

@method_decorator(login_required, name='dispatch')
class ProductDetailView(DetailView):
    model = Product
    template_name = 'inventory/product_detail.html'
    context_object_name = 'product'

@method_decorator(login_required, name='dispatch')
class CustomerListView(ListView):
    model = Customer
    template_name = 'inventory/customer_list.html'
    context_object_name = 'customers'
    paginate_by = 20

@login_required
def customer_create(request):
    """Create a new customer"""
    if request.method == 'POST':
        form = CustomerForm(request.POST)
        if form.is_valid():
            customer = form.save()
            messages.success(request, f'Customer "{customer.name}" created successfully!')
            return redirect('inventory:customer_list')
    else:
        form = CustomerForm()
    
    return render(request, 'inventory/customer_form.html', {'form': form, 'title': 'Create Customer'})

@login_required
def supplier_create(request):
    """Create a new supplier"""
    if request.method == 'POST':
        form = SupplierForm(request.POST)
        if form.is_valid():
            supplier = form.save()
            messages.success(request, f'Supplier "{supplier.name}" created successfully!')
            return redirect('inventory:supplier_list')
    else:
        form = SupplierForm()
    
    return render(request, 'inventory/supplier_form.html', {'form': form, 'title': 'Create Supplier'})

@login_required
def product_create(request):
    """Create a new product"""
    if request.method == 'POST':
        form = ProductForm(request.POST)
        if form.is_valid():
            product = form.save()
            messages.success(request, f'Product "{product.name}" created successfully!')
            return redirect('inventory:product_list')
    else:
        form = ProductForm()
    
    return render(request, 'inventory/product_form.html', {'form': form, 'title': 'Create Product'})

@login_required
def product_edit(request, pk):
    """Edit an existing product"""
    product = get_object_or_404(Product, pk=pk)
    if request.method == 'POST':
        form = ProductForm(request.POST, instance=product)
        if form.is_valid():
            form.save()
            messages.success(request, f'Product "{product.name}" updated successfully!')
            return redirect('inventory:product_list')
    else:
        form = ProductForm(instance=product)
    
    return render(request, 'inventory/product_form.html', {'form': form, 'title': f'Edit Product: {product.name}'})

@login_required
def category_list(request):
    """List all product categories"""
    categories = Category.objects.all().order_by('name')
    return render(request, 'inventory/category_list.html', {'categories': categories})

@login_required
def category_create(request):
    """Create a new product category"""
    if request.method == 'POST':
        form = CategoryForm(request.POST)
        if form.is_valid():
            category = form.save()
            messages.success(request, f'Category "{category.name}" created successfully!')
            return redirect('inventory:category_list')
    else:
        form = CategoryForm()
    
    return render(request, 'inventory/category_form.html', {'form': form, 'title': 'Create Category'})

@login_required
def category_edit(request, pk):
    """Edit an existing product category"""
    category = get_object_or_404(Category, pk=pk)
    if request.method == 'POST':
        form = CategoryForm(request.POST, instance=category)
        if form.is_valid():
            form.save()
            messages.success(request, f'Category "{category.name}" updated successfully!')
            return redirect('inventory:category_list')
    else:
        form = CategoryForm(instance=category)
    
    return render(request, 'inventory/category_form.html', {'form': form, 'title': f'Edit Category: {category.name}'})


@login_required
def category_delete(request, pk):
    """Delete a product category"""
    from users.views import is_administrator
    if not is_administrator(request.user):
        messages.error(request, 'You do not have permission to delete categories.')
        return redirect('inventory:category_list')
    
    category = get_object_or_404(Category, pk=pk)
    
    # Check if category is used by any products
    if category.product_set.exists():
        messages.error(request, f'Cannot delete category "{category.name}" because it is still used by products.')
        return redirect('inventory:category_list')
    
    if request.method == 'POST':
        category_name = category.name
        category.delete()
        messages.success(request, f'Category "{category_name}" deleted successfully!')
        return redirect('inventory:category_list')
    
    return render(request, 'inventory/category_confirm_delete.html', {'category': category})

@method_decorator(login_required, name='dispatch')
class CustomerDetailView(DetailView):
    model = Customer
    template_name = 'inventory/customer_detail.html'
    context_object_name = 'customer'

@method_decorator(login_required, name='dispatch')
class SupplierListView(ListView):
    model = Supplier
    template_name = 'inventory/supplier_list.html'
    context_object_name = 'suppliers'
    paginate_by = 20


@method_decorator(login_required, name='dispatch')
class SupplierDetailView(DetailView):
    model = Supplier
    template_name = 'inventory/supplier_detail.html'
    context_object_name = 'supplier'

@login_required
def customer_edit(request, pk):
    """Edit an existing customer"""
    customer = get_object_or_404(Customer, pk=pk)
    if request.method == 'POST':
        form = CustomerForm(request.POST, instance=customer)
        if form.is_valid():
            form.save()
            messages.success(request, f'Customer "{customer.name}" updated successfully!')
            return redirect('inventory:customer_list')
    else:
        form = CustomerForm(instance=customer)
    
    return render(request, 'inventory/customer_form.html', {'form': form, 'title': f'Edit Customer: {customer.name}'})


@login_required
def supplier_edit(request, pk):
    """Edit an existing supplier"""
    supplier = get_object_or_404(Supplier, pk=pk)
    if request.method == 'POST':
        form = SupplierForm(request.POST, instance=supplier)
        if form.is_valid():
            form.save()
            messages.success(request, f'Supplier "{supplier.name}" updated successfully!')
            return redirect('inventory:supplier_list')
    else:
        form = SupplierForm(instance=supplier)
    
    return render(request, 'inventory/supplier_form.html', {'form': form, 'title': f'Edit Supplier: {supplier.name}'})


@login_required
def product_delete(request, pk):
    """Delete a product"""
    from users.views import is_administrator
    if not is_administrator(request.user):
        messages.error(request, 'You do not have permission to delete products.')
        return redirect('inventory:product_list')
    
    product = get_object_or_404(Product, pk=pk)
    
    # Check if product is used in any orders or stock movements
    if (product.manufacturing_orders.exists() or
        product.purchase_order_items.exists() or
        product.sale_order_items.exists() or
        product.stock_movements.exists()):
        messages.error(request, f'Cannot delete product "{product.name}" because it is still referenced in orders or stock movements.')
        return redirect('inventory:product_list')
    
    if request.method == 'POST':
        product_name = product.name
        product.delete()
        messages.success(request, f'Product "{product_name}" deleted successfully!')
        return redirect('inventory:product_list')
    
    return render(request, 'inventory/product_confirm_delete.html', {'product': product})


@login_required
def customer_delete(request, pk):
    """Delete a customer"""
    from users.views import is_administrator
    if not is_administrator(request.user):
        messages.error(request, 'You do not have permission to delete customers.')
        return redirect('inventory:customer_list')
    
    customer = get_object_or_404(Customer, pk=pk)
    
    # Check if customer is used in any sales orders
    # We need to check the sales app's Customer model which has the relationship
    from sales.models import Customer as SalesCustomer
    try:
        sales_customer = SalesCustomer.objects.get(code=customer.code)
        if sales_customer.sale_orders.exists():
            messages.error(request, f'Cannot delete customer "{customer.name}" because it is still referenced in sales orders.')
            return redirect('inventory:customer_list')
    except SalesCustomer.DoesNotExist:
        # If there's no corresponding sales customer, that's fine
        pass
    
    if request.method == 'POST':
        customer_name = customer.name
        customer.delete()
        messages.success(request, f'Customer "{customer_name}" deleted successfully!')
        return redirect('inventory:customer_list')
    
    return render(request, 'inventory/customer_confirm_delete.html', {'customer': customer})


@login_required
def supplier_delete(request, pk):
    """Delete a supplier"""
    from users.views import is_administrator
    if not is_administrator(request.user):
        messages.error(request, 'You do not have permission to delete suppliers.')
        return redirect('inventory:supplier_list')
    
    supplier = get_object_or_404(Supplier, pk=pk)
    
    # Check if supplier is used in any purchase orders
    # We need to check the purchase app's Supplier model which has the relationship
    from purchase.models import Supplier as PurchaseSupplier
    try:
        purchase_supplier = PurchaseSupplier.objects.get(code=supplier.code)
        if purchase_supplier.purchase_orders.exists():
            messages.error(request, f'Cannot delete supplier "{supplier.name}" because it is still referenced in purchase orders.')
            return redirect('inventory:supplier_list')
    except PurchaseSupplier.DoesNotExist:
        # If there's no corresponding purchase supplier, that's fine
        pass
    
    if request.method == 'POST':
        supplier_name = supplier.name
        supplier.delete()
        messages.success(request, f'Supplier "{supplier_name}" deleted successfully!')
        return redirect('inventory:supplier_list')
    
    return render(request, 'inventory/supplier_confirm_delete.html', {'supplier': supplier})