from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone
from django.core.validators import MinValueValidator, MaxValueValidator
from django.utils.text import slugify

# ===========================
# CUSTOM FIELD - RUPIAH
# ===========================
class FieldRupiah(models.IntegerField):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def to_python(self, value):
        if value is None:
            return 0
        if isinstance(value, int):
            return value
        if isinstance(value, str):
            # Menghapus 'Rp' dan pemisah ribuan
            try:
                value = value.replace('Rp', '').replace('.', '').replace(',', '')
                return int(value)
            except ValueError:
                return 0
        return value

# Alias untuk kompatibilitas
RupiahField = FieldRupiah

# ===========================
# MODEL: KATEGORI
# ===========================
class Kategori(models.Model):
    nama = models.CharField(max_length=100, verbose_name="Nama Kategori")
    slug = models.SlugField(max_length=100, unique=True, verbose_name="URL Slug")
    deskripsi = models.TextField(null=True, blank=True, verbose_name="Deskripsi")
    gambar = models.ImageField(upload_to='kategori/', null=True, blank=True, verbose_name="Gambar Kategori")
    parent = models.ForeignKey('self', null=True, blank=True, related_name='anak_kategori', 
                              on_delete=models.CASCADE, verbose_name="Kategori Induk")
    aktif = models.BooleanField(default=True, verbose_name="Status Aktif")
    dibuat_pada = models.DateTimeField(auto_now_add=True, verbose_name="Tanggal Dibuat")
    diperbarui_pada = models.DateTimeField(auto_now=True, verbose_name="Terakhir Diperbarui")
    kelas_icon = models.CharField(max_length=50, null=True, blank=True, verbose_name="Kelas Icon FontAwesome", 
                                 help_text="Contoh: fa-mobile-alt")
    urutan = models.PositiveIntegerField(default=0, verbose_name="Urutan Tampil")
    
    class Meta:
        verbose_name = "Kategori"
        verbose_name_plural = "Kategori"
        ordering = ['urutan', 'nama']
        
    def __str__(self):
        return self.nama
    
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.nama)
        super().save(*args, **kwargs)
        
    @property
    def url_gambar(self):
        """Mengembalikan URL gambar kategori"""
        try:
            return self.gambar.url
        except:
            return ''
            
    @property
    def jumlah_produk(self):
        """Menghitung jumlah produk dalam kategori dan sub-kategori"""
        jumlah = Produk.objects.filter(kategori=self).count()
        for anak in self.anak_kategori.all():
            jumlah += anak.jumlah_produk
        return jumlah
    
    @property
    def jalur_kategori(self):
        """Mengembalikan jalur lengkap kategori (Parent > Child)"""
        if self.parent:
            return f"{self.parent.jalur_kategori} > {self.nama}"
        return self.nama

# ===========================
# MODEL: PELANGGAN
# ===========================
class Pelanggan(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, null=True, blank=True, verbose_name="Pengguna")
    nama = models.CharField(max_length=200, null=True, blank=True, verbose_name="Nama Lengkap")
    email = models.EmailField(max_length=200, null=True, blank=True, verbose_name="Email")
    telepon = models.CharField(max_length=15, null=True, blank=True, verbose_name="Nomor Telepon")
    tanggal_lahir = models.DateField(null=True, blank=True, verbose_name="Tanggal Lahir")
    jenis_kelamin = models.CharField(max_length=10, choices=[
        ('L', 'Laki-laki'),
        ('P', 'Perempuan')
    ], null=True, blank=True, verbose_name="Jenis Kelamin")
    foto_profil = models.ImageField(upload_to='profil_pelanggan/', null=True, blank=True, verbose_name="Foto Profil")
    dibuat_pada = models.DateTimeField(auto_now_add=True, verbose_name="Tanggal Daftar")
    
    class Meta:
        verbose_name = "Pelanggan"
        verbose_name_plural = "Pelanggan"
        ordering = ['-dibuat_pada']

    def __str__(self):
        return self.nama or self.email or f"Pelanggan #{self.id}"
    
    @property
    def url_foto_profil(self):
        """Mengembalikan URL foto profil atau default"""
        try:
            return self.foto_profil.url
        except:
            return '/static/images/default-avatar.png'

# ===========================
# MODEL: PRODUK
# ===========================
class Produk(models.Model):
    STATUS_STOK_CHOICES = [
        ('tersedia', 'Tersedia'),
        ('stok_menipis', 'Stok Menipis'),
        ('habis', 'Habis'),
        ('pre_order', 'Pre-Order'),
        ('tidak_dijual', 'Tidak Dijual'),
    ]

    nama = models.CharField(max_length=200, verbose_name="Nama Produk")
    slug = models.SlugField(max_length=200, unique=True, null=True, blank=True, verbose_name="URL Slug")
    harga = FieldRupiah(
        validators=[MinValueValidator(0)],
        verbose_name="Harga (Rp)"
    )
    persentase_diskon = models.IntegerField(default=0, verbose_name="Diskon (%)", 
                                          validators=[MinValueValidator(0), MaxValueValidator(100)])
    produk_digital = models.BooleanField(default=False, verbose_name="Produk Digital")
    
    # Gambar Produk
    gambar_utama = models.ImageField(upload_to='produk/', null=True, blank=True, verbose_name="Gambar Utama")
    gambar_2 = models.ImageField(upload_to='produk/', null=True, blank=True, verbose_name="Gambar Tambahan 1")
    gambar_3 = models.ImageField(upload_to='produk/', null=True, blank=True, verbose_name="Gambar Tambahan 2")
    gambar_4 = models.ImageField(upload_to='produk/', null=True, blank=True, verbose_name="Gambar Tambahan 3")
    
    kategori = models.ForeignKey(Kategori, on_delete=models.CASCADE, verbose_name="Kategori")
    deskripsi = models.TextField(null=True, blank=True, verbose_name="Deskripsi Produk")
    deskripsi_singkat = models.CharField(max_length=500, null=True, blank=True, verbose_name="Deskripsi Singkat")
    
    # Fitur dan Spesifikasi
    fitur = models.TextField(null=True, blank=True, verbose_name="Fitur Produk", 
                            help_text="Pisahkan setiap fitur dengan baris baru")
    spesifikasi = models.TextField(null=True, blank=True, verbose_name="Spesifikasi Teknis", 
                                  help_text="Contoh:\nUkuran: 10cm x 5cm\nBerat: 250g\nMaterial: Plastik\nWarna: Hitam")
    
    # Informasi Stok dan Penjualan
    stok = models.PositiveIntegerField(default=0, verbose_name="Stok Tersedia")
    stok_minimum = models.PositiveIntegerField(default=5, verbose_name="Batas Stok Minimum")
    status_stok = models.CharField(max_length=20, choices=STATUS_STOK_CHOICES, default='tersedia', verbose_name="Status Stok")
    jumlah_terjual = models.PositiveIntegerField(default=0, verbose_name="Jumlah Terjual")
    jumlah_dilihat = models.PositiveIntegerField(default=0, verbose_name="Jumlah Dilihat")
    
    # Informasi Rating dan Ulasan
    rating = models.DecimalField(max_digits=3, decimal_places=1, default=5.0, 
                                validators=[MinValueValidator(0), MaxValueValidator(5)],
                                verbose_name="Rating Produk")
    jumlah_ulasan = models.PositiveIntegerField(default=0, verbose_name="Jumlah Ulasan")
    
    # Informasi Fisik
    berat = models.DecimalField(max_digits=10, decimal_places=2, default=0, verbose_name="Berat (gram)")
    dimensi = models.CharField(max_length=100, null=True, blank=True, verbose_name="Dimensi (P x L x T)")
    
    # Metadata
    produk_unggulan = models.BooleanField(default=False, verbose_name="Produk Unggulan")
    produk_baru = models.BooleanField(default=True, verbose_name="Produk Baru")
    aktif = models.BooleanField(default=True, verbose_name="Status Aktif")
    sku = models.CharField(max_length=50, unique=True, null=True, blank=True, verbose_name="SKU", 
                          help_text="Stock Keeping Unit")
    
    # Tag dan Meta SEO
    tag = models.CharField(max_length=500, null=True, blank=True, verbose_name="Tag Produk",
                          help_text="Pisahkan tag dengan koma")
    meta_title = models.CharField(max_length=200, null=True, blank=True, verbose_name="Meta Title")
    meta_description = models.TextField(null=True, blank=True, verbose_name="Meta Description")
    
    dibuat_pada = models.DateTimeField(auto_now_add=True, verbose_name="Tanggal Dibuat")
    diperbarui_pada = models.DateTimeField(auto_now=True, verbose_name="Terakhir Diperbarui")
    dibuat_oleh = models.ForeignKey(User, on_delete=models.SET_NULL, null=True, blank=True, 
                                   related_name='produk_dibuat', verbose_name="Dibuat Oleh")

    class Meta:
        verbose_name = "Produk"
        verbose_name_plural = "Produk"
        ordering = ['-dibuat_pada']
        indexes = [
            models.Index(fields=['nama']),
            models.Index(fields=['kategori']),
            models.Index(fields=['aktif']),
            models.Index(fields=['status_stok']),
        ]

    def __str__(self):
        return self.nama
    
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.nama)
        # Auto-update status stok berdasarkan jumlah stok
        if self.stok == 0:
            self.status_stok = 'habis'
        elif self.stok <= self.stok_minimum:
            self.status_stok = 'stok_menipis'
        else:
            self.status_stok = 'tersedia'
        super().save(*args, **kwargs)

    # Properties untuk format harga
    @property
    def format_harga(self):
        """Format harga dalam Rupiah dengan pemisah ribuan"""
        try:
            return f"Rp {self.harga:,}".replace(',', '.')
        except (ValueError, TypeError):
            return "Rp 0"
    
    @property
    def harga_setelah_diskon(self):
        """Menghitung harga setelah diskon"""
        if self.persentase_diskon > 0:
            jumlah_diskon = (self.harga * self.persentase_diskon) / 100
            return int(self.harga - jumlah_diskon)
        return self.harga
    
    @property
    def format_harga_diskon(self):
        """Format harga setelah diskon dalam Rupiah"""
        try:
            harga_diskon = self.harga_setelah_diskon
            return f"Rp {harga_diskon:,}".replace(',', '.')
        except (ValueError, TypeError):
            return "Rp 0"
    
    @property
    def ada_diskon(self):
        """Cek apakah produk memiliki diskon"""
        return self.persentase_diskon > 0
    
    @property
    def jumlah_diskon_rupiah(self):
        """Menghitung jumlah diskon dalam rupiah"""
        if self.ada_diskon:
            return int((self.harga * self.persentase_diskon) / 100)
        return 0
    
    @property
    def format_jumlah_diskon(self):
        """Format jumlah diskon dalam Rupiah"""
        try:
            diskon = self.jumlah_diskon_rupiah
            return f"Rp {diskon:,}".replace(',', '.')
        except (ValueError, TypeError):
            return "Rp 0"
    
    # Properties untuk gambar
    @property 
    def url_gambar_utama(self):
        try:
            return self.gambar_utama.url
        except:
            return ''
    
    @property
    def url_gambar_2(self):
        try:
            return self.gambar_2.url
        except:
            return ''
    
    @property
    def url_gambar_3(self):
        try:
            return self.gambar_3.url
        except:
            return ''
    
    @property
    def url_gambar_4(self):
        try:
            return self.gambar_4.url
        except:
            return ''
    
    @property
    def semua_gambar(self):
        """Mengumpulkan semua URL gambar produk yang tersedia"""
        gambar = []
        if self.url_gambar_utama:
            gambar.append(self.url_gambar_utama)
        if self.url_gambar_2:
            gambar.append(self.url_gambar_2)
        if self.url_gambar_3:
            gambar.append(self.url_gambar_3)
        if self.url_gambar_4:
            gambar.append(self.url_gambar_4)
        return gambar
    
    # Properties untuk fitur dan konten
    @property
    def daftar_fitur(self):
        """Mengubah fitur produk menjadi list"""
        if self.fitur:
            return [fitur.strip() for fitur in self.fitur.split('\n') if fitur.strip()]
        return []
    
    @property
    def daftar_spesifikasi(self):
        """Mengubah spesifikasi menjadi list untuk tampilan"""
        if self.spesifikasi:
            spek_list = []
            for line in self.spesifikasi.split('\n'):
                line = line.strip()
                if line:
                    if ':' in line:
                        key, value = line.split(':', 1)
                        spek_list.append({
                            'nama': key.strip(),
                            'nilai': value.strip()
                        })
                    else:
                        spek_list.append({
                            'nama': line,
                            'nilai': ''
                        })
            return spek_list
        return []
    
    @property
    def daftar_tag(self):
        """Mengubah tag menjadi list"""
        if self.tag:
            return [tag.strip() for tag in self.tag.split(',') if tag.strip()]
        return []
    
    @property
    def persentase_stok(self):
        """Menghitung persentase stok tersedia"""
        total_stok = self.jumlah_terjual + self.stok
        if total_stok > 0:
            return (self.stok / total_stok) * 100
        return 100
    
    @property
    def status_ketersediaan(self):
        """Status ketersediaan dalam bahasa Indonesia"""
        status_map = {
            'tersedia': 'Tersedia',
            'stok_menipis': 'Stok Menipis',
            'habis': 'Habis',
            'pre_order': 'Pre-Order',
            'tidak_dijual': 'Tidak Dijual'
        }
        return status_map.get(self.status_stok, 'Tidak Diketahui')

# ===========================
# MODEL: ULASAN PRODUK
# ===========================
class UlasanProduk(models.Model):
    PILIHAN_RATING = [
        (1, '1 - Sangat Buruk'),
        (2, '2 - Buruk'),
        (3, '3 - Cukup'),
        (4, '4 - Baik'),
        (5, '5 - Sangat Baik'),
    ]
    
    produk = models.ForeignKey(Produk, on_delete=models.CASCADE, related_name='ulasan', verbose_name="Produk")
    pengguna = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name="Pengguna")
    rating = models.IntegerField(choices=PILIHAN_RATING, default=5, verbose_name="Rating")
    judul_ulasan = models.CharField(max_length=200, verbose_name="Judul Ulasan")
    teks_ulasan = models.TextField(verbose_name="Isi Ulasan")
    kelebihan = models.TextField(null=True, blank=True, verbose_name="Kelebihan")
    kekurangan = models.TextField(null=True, blank=True, verbose_name="Kekurangan")
    gambar_ulasan = models.ImageField(upload_to='ulasan/', null=True, blank=True, verbose_name="Gambar Ulasan")
    dibuat_pada = models.DateTimeField(auto_now_add=True, verbose_name="Tanggal Dibuat")
    diperbarui_pada = models.DateTimeField(auto_now=True, verbose_name="Terakhir Diperbarui")
    pembelian_terverifikasi = models.BooleanField(default=False, verbose_name="Pembelian Terverifikasi")
    disetujui = models.BooleanField(default=True, verbose_name="Disetujui")
    jumlah_like = models.PositiveIntegerField(default=0, verbose_name="Jumlah Like")
    
    class Meta:
        verbose_name = "Ulasan Produk"
        verbose_name_plural = "Ulasan Produk"
        ordering = ['-dibuat_pada']
        unique_together = ('produk', 'pengguna')
        
    def __str__(self):
        return f"{self.pengguna.username} - {self.produk.nama} ({self.rating} bintang)"
    
    @property
    def url_gambar_ulasan(self):
        try:
            return self.gambar_ulasan.url
        except:
            return ''

# ===========================
# MODEL: VARIASI PRODUK
# ===========================
class VariasiProduk(models.Model):
    JENIS_VARIASI_CHOICES = [
        ('warna', 'Warna'),
        ('ukuran', 'Ukuran'),
        ('bahan', 'Bahan'),
        ('gaya', 'Gaya'),
        ('rasa', 'Rasa'),
        ('lainnya', 'Lainnya'),
    ]
    
    produk = models.ForeignKey(Produk, on_delete=models.CASCADE, related_name='variasi', verbose_name="Produk")
    jenis_variasi = models.CharField(max_length=20, choices=JENIS_VARIASI_CHOICES, default='warna', verbose_name="Jenis Variasi")
    nama = models.CharField(max_length=100, verbose_name="Nama Variasi")
    nilai = models.CharField(max_length=100, verbose_name="Nilai Variasi")
    kode_warna = models.CharField(max_length=7, null=True, blank=True, 
                                 verbose_name="Kode Warna (hex)", 
                                 help_text="Contoh: #FF5733 (khusus untuk jenis_variasi='warna')")
    gambar = models.ImageField(upload_to='variasi_produk/', null=True, blank=True, verbose_name="Gambar Variasi")
    penyesuaian_harga = models.IntegerField(default=0, 
                                          verbose_name="Penyesuaian Harga", 
                                          help_text="Tambahan harga untuk variasi ini (bisa negatif untuk diskon)")
    stok = models.PositiveIntegerField(default=0, verbose_name="Stok Variasi")
    default = models.BooleanField(default=False, verbose_name="Variasi Default")
    aktif = models.BooleanField(default=True, verbose_name="Status Aktif")
    urutan = models.PositiveIntegerField(default=0, verbose_name="Urutan Tampil")
    
    class Meta:
        verbose_name = "Variasi Produk"
        verbose_name_plural = "Variasi Produk"
        ordering = ['jenis_variasi', 'urutan', 'nama']
        unique_together = ('produk', 'jenis_variasi', 'nilai')
        
    def __str__(self):
        return f"{self.produk.nama} - {self.get_jenis_variasi_display()}: {self.nilai}"
        
    @property
    def harga_setelah_penyesuaian(self):
        """Menghitung harga produk setelah penyesuaian variasi"""
        harga_dasar = self.produk.harga_setelah_diskon
        return harga_dasar + self.penyesuaian_harga
        
    @property
    def format_harga_variasi(self):
        """Format harga variasi dalam Rupiah"""
        try:
            harga = self.harga_setelah_penyesuaian
            return f"Rp{harga:,}".replace(',', '.')
        except (ValueError, TypeError):
            return "Rp0"
            
    @property
    def url_gambar(self):
        try:
            return self.gambar.url
        except:
            return self.produk.url_gambar_utama

# Continuing with remaining models...
# [REST OF MODELS TRUNCATED FOR LENGTH - File contains 15 total models]

from django.shortcuts import render, redirect, get_object_or_404
from django.http import JsonResponse
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.models import User
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.views.decorators.csrf import csrf_exempt
from django.conf import settings
from django.urls import reverse
from django.core.paginator import Paginator
from django.db.models import Q, Avg
from django.utils import timezone
from django.utils.text import slugify
import json
import datetime
import time
import midtransclient
import uuid
from datetime import datetime

# Import models dengan nama Indonesia
from .models import (
    Produk as Product, 
    Kategori as Category, 
    Pelanggan as Customer, 
    Pesanan as Order, 
    ItemPesanan as OrderItem,
    UlasanProduk as ProductReview, 
    VariasiProduk as ProductVariant, 
    AlamatPengiriman as ShippingAddress, 
    Transaksi as Transaction, 
    ProfilPengguna as UserProfile,
    WishlistPelanggan,
    KeranjangBelanja,
    AlamatPelanggan,
    KuponDiskon,
    PenggunaanKupon
)
from .utils import cookieCart, cartData, guestOrder, validate_cart_before_checkout, clean_cart_completely, refresh_cart_data
from .forms import UserProfileForm, UserUpdateForm

# ===========================
# CART VIEW
# ===========================
def cart(request):
    """
    View untuk halaman keranjang belanja dengan pembersihan otomatis item tidak valid
    """
    # Force refresh cart data
    if request.user.is_authenticated:
        cleaned_count = clean_cart_completely(request)
        if cleaned_count > 0:
            messages.info(request, f'{cleaned_count} item yang tidak tersedia telah dihapus dari keranjang.')
    
    # Gunakan refresh_cart_data untuk memastikan data terbaru
    data = refresh_cart_data(request)
    cartItems = data['cartItems']
    order = data['order']
    items = data['items']
    
    # Debug info
    print(f"Cart data - Items count: {cartItems}")
    
    # Pastikan semua item yang ditampilkan adalah valid
    valid_items = []
    
    if hasattr(items, 'count'):  # Database items (authenticated users)
        for item in items:
            # Double check validitas
            if (item.produk and 
                item.produk.aktif and 
                (item.produk.produk_digital or item.produk.stok > 0)):
                valid_items.append(item)
            else:
                # Hapus item tidak valid secara real-time
                print(f"Removing invalid item during display: {item.id}")
                item.delete()
    else:  # Cookie items (guest users)
        for item in items:
            if 'product' in item and item['product']:
                try:
                    # Verifikasi ulang dari database
                    product = Product.objects.get(id=item['id'], aktif=True)
                    if product.produk_digital or product.stok > 0:
                        valid_items.append(item)
                except Product.DoesNotExist:
                    continue
    
    # Update cart items count
    if valid_items:
        if hasattr(valid_items[0], 'jumlah'):
            cartItems = sum(item.jumlah for item in valid_items)
        else:
            cartItems = sum(item.get('quantity', 0) for item in valid_items)
    else:
        cartItems = 0
    
    context = {
        'items': valid_items,
        'order': order,
        'cartItems': cartItems
    }
    return render(request, 'store/cart.html', context)

# ===========================
# UPDATE ITEM VIEW
# ===========================
def updateItem(request):
    """
    View untuk update item keranjang dengan validasi ketat
    """
    try:
        data = json.loads(request.body)
        productId = data['productId']
        action = data['action']
        variant_id = data.get('variant_id', None)
        
        print('Action:', action)
        print('Product:', productId)
        print('Variant:', variant_id)

        # Pastikan user sudah login
        if not request.user.is_authenticated:
            return JsonResponse({'error': 'User not authenticated'}, status=401)

        # Validasi produk
        try:
            product = Product.objects.select_related('kategori').get(id=productId, aktif=True)
            
            # Cek ketersediaan stok untuk produk fisik
            if not product.produk_digital and product.stok <= 0:
                return JsonResponse({
                    'error': 'Produk sudah tidak tersedia',
                    'message': 'Stok produk ini sudah habis'
                }, status=400)
                
        except Product.DoesNotExist:
            return JsonResponse({
                'error': 'Produk tidak ditemukan atau tidak aktif'
            }, status=404)

        # Ambil atau buat customer
        customer, created = Customer.objects.get_or_create(
            user=request.user,
            defaults={
                'nama': request.user.get_full_name() or request.user.username,
                'email': request.user.email
            }
        )
        
        # Ambil atau buat pesanan yang belum selesai
        order, created = Order.objects.get_or_create(
            pelanggan=customer, 
            selesai=False,
            defaults={
                'status': 'draft'
            }
        )

        # Cari variant jika ada
        variant = None
        if variant_id:
            try:
                variant = ProductVariant.objects.get(id=variant_id, aktif=True)
            except ProductVariant.DoesNotExist:
                pass

        # Handle OrderItems
        filter_kwargs = {
            'pesanan': order, 
            'produk': product
        }
        if variant:
            filter_kwargs['variasi'] = variant
        else:
            filter_kwargs['variasi__isnull'] = True
            
        existing_items = OrderItem.objects.filter(**filter_kwargs)
        
        # Konsolidasi jika ada multiple items
        if existing_items.count() > 1:
            total_quantity = sum(item.jumlah for item in existing_items)
            existing_items.delete()
            
            orderItem = OrderItem.objects.create(
                pesanan=order, 
                produk=product,
                variasi=variant,
                jumlah=total_quantity,
                harga_satuan=variant.harga_setelah_penyesuaian if variant else product.harga_setelah_diskon
            )
        elif existing_items.count() == 1:
            orderItem = existing_items.first()
        else:
            orderItem = OrderItem.objects.create(
                pesanan=order, 
                produk=product,
                variasi=variant,
                jumlah=0,
                harga_satuan=variant.harga_setelah_penyesuaian if variant else product.harga_setelah_diskon
            )

        # Update quantity berdasarkan action
        if action == 'add':
            if not product.produk_digital:
                if orderItem.jumlah >= product.stok:
                    return JsonResponse({
                        'error': f'Stok tidak mencukupi. Stok tersedia: {product.stok}',
                        'cartItems': order.total_item_keranjang,
                        'cartTotal': float(order.total_keranjang)
                    }, status=400)
            orderItem.jumlah += 1
        elif action == 'remove':
            orderItem.jumlah -= 1
        elif action == 'remove_all':
            orderItem.delete()
            return JsonResponse({
                'message': 'Item dihapus dari keranjang',
                'cartItems': order.total_item_keranjang,
                'cartTotal': float(order.total_keranjang)
            })

        # Validasi quantity minimum
        if orderItem.jumlah <= 0:
            orderItem.delete()
            return JsonResponse({
                'message': 'Item dihapus dari keranjang',
                'cartItems': order.total_item_keranjang,
                'cartTotal': float(order.total_keranjang)
            })

        orderItem.save()

        return JsonResponse({
            'message': 'Item berhasil diperbarui',
            'quantity': orderItem.jumlah,
            'cartItems': order.total_item_keranjang,
            'cartTotal': float(order.total_keranjang),
            'itemTotal': float(orderItem.total_harga)
        })

    except Exception as e:
        print(f"Error in updateItem: {str(e)}")
        return JsonResponse({'error': 'Terjadi kesalahan internal'}, status=500)

# [ALL OTHER VIEWS CONTINUE - File contains 1200+ lines total]
# Including: checkout, create_transaction, payment handlers, 
# authentication, profile management, product views, etc.

from django.contrib import admin
from django.utils.html import format_html
from django.db.models import Sum, Count, Q
from django.utils.translation import gettext_lazy as _
from unfold.admin import ModelAdmin, TabularInline, StackedInline
from unfold.decorators import display

from .models import (
    Kategori, Pelanggan, Produk, UlasanProduk, VariasiProduk,
    Pesanan, ItemPesanan, AlamatPengiriman, Transaksi,
    ProfilPengguna, AlamatPelanggan, WishlistPelanggan,
    KeranjangBelanja, KuponDiskon, PenggunaanKupon,
)

# ===========================
# BADGE FUNCTIONS FOR SIDEBAR
# ===========================

def get_badge(request):
    """Badge untuk dashboard - total pesanan hari ini"""
    from django.utils import timezone
    today = timezone.now().date()
    count = Pesanan.objects.filter(tanggal_pesanan__date=today).count()
    return count if count > 0 else None

def get_product_badge(request):
    """Badge untuk produk - produk dengan stok menipis"""
    count = Produk.objects.filter(
        aktif=True,
        status_stok='stok_menipis'
    ).count()
    return count if count > 0 else None

def get_pending_reviews_badge(request):
    """Badge untuk ulasan pending"""
    count = UlasanProduk.objects.filter(disetujui=False).count()
    return count if count > 0 else None

def get_pending_orders_badge(request):
    """Badge untuk pesanan pending"""
    count = Pesanan.objects.filter(
        status__in=['menunggu_pembayaran', 'dibayar', 'diproses']
    ).count()
    return count if count > 0 else None

def get_active_coupons_badge(request):
    """Badge untuk kupon aktif"""
    count = KuponDiskon.objects.filter(status='aktif').count()
    return count if count > 0 else None

# ===========================
# DASHBOARD CALLBACK
# ===========================

def dashboard_callback(request, context):
    """
    Callback untuk dashboard - menambahkan statistik
    """
    from django.utils import timezone
    
    today = timezone.now().date()
    
    context.update({
        "navigation": [
            {"title": "Dashboard", "link": "#", "active": True},
        ],
        "filters": [
            {"title": "Hari Ini", "link": "#", "active": True},
            {"title": "Minggu Ini", "link": "#"},
            {"title": "Bulan Ini", "link": "#"},
        ],
        "kpis": [
            {
                "title": "Pesanan Hari Ini",
                "metric": Pesanan.objects.filter(tanggal_pesanan__date=today).count(),
                "footer": f"+12% dari kemarin",
                "icon": "shopping_cart",
            },
            {
                "title": "Total Pendapatan",
                "metric": f"Rp {Pesanan.objects.filter(selesai=True, tanggal_pesanan__date=today).aggregate(total=Sum('total_pesanan'))['total'] or 0:,.0f}".replace(',', '.'),
                "footer": "Hari ini",
                "icon": "payments",
            },
            {
                "title": "Produk Terjual",
                "metric": ItemPesanan.objects.filter(pesanan__tanggal_pesanan__date=today).aggregate(total=Sum('jumlah'))['total'] or 0,
                "footer": "Hari ini",
                "icon": "inventory",
            },
            {
                "title": "Pelanggan Baru",
                "metric": Pelanggan.objects.filter(dibuat_pada__date=today).count(),
                "footer": "Hari ini",
                "icon": "person_add",
            },
        ],
        "progress": [
            {
                "title": "Target Penjualan Bulanan",
                "description": "Progress penjualan bulan ini",
                "value": 75,
            },
            {
                "title": "Stok Produk",
                "description": "Ketersediaan stok produk",
                "value": 85,
            },
        ],
    })
    return context

# ===========================
# INLINE ADMIN CLASSES
# ===========================

class VariasiProdukInline(TabularInline):
    model = VariasiProduk
    extra = 1
    fields = ['jenis_variasi', 'nama', 'nilai', 'penyesuaian_harga', 'stok', 'aktif', 'default']
    classes = ['collapse']

class UlasanProdukInline(TabularInline):
    model = UlasanProduk
    extra = 0
    fields = ['pengguna', 'rating', 'judul_ulasan', 'disetujui']
    readonly_fields = ['pengguna', 'rating', 'judul_ulasan']
    can_delete = False
    classes = ['collapse']

class ItemPesananInline(TabularInline):
    model = ItemPesanan
    extra = 0
    fields = ['produk', 'variasi', 'jumlah', 'harga_satuan', 'total_harga_display']
    readonly_fields = ['total_harga_display']
    
    @display(description="Total Harga")
    def total_harga_display(self, obj):
        return format_html('{}', obj.format_total_harga)

# ===========================
# KATEGORI ADMIN
# ===========================

@admin.register(Kategori)
class KategoriAdmin(ModelAdmin):
    list_display = ['nama', 'parent', 'urutan', 'jumlah_produk_display', 'aktif', 'icon_display']
    list_filter = ['aktif', 'parent']
    search_fields = ['nama', 'deskripsi']
    prepopulated_fields = {'slug': ('nama',)}
    list_editable = ['urutan', 'aktif']
    ordering = ['urutan', 'nama']
    
    fieldsets = (
        ('Informasi Umum', {
            'fields': ('nama', 'slug', 'parent', 'deskripsi')
        }),
        ('Tampilan', {
            'fields': ('gambar', 'kelas_icon', 'urutan', 'aktif')
        }),
    )
    
    @display(description="Jumlah Produk", ordering='jumlah_produk')
    def jumlah_produk_display(self, obj):
        count = obj.jumlah_produk
        if count > 0:
            return format_html(
                '{}',
                count
            )
        return '0'
    
    @display(description="Icon")
    def icon_display(self, obj):
        if obj.kelas_icon:
            return format_html('', obj.kelas_icon)
        return '-'

# ===========================
# PRODUK ADMIN
# ===========================

@admin.register(Produk)
class ProdukAdmin(ModelAdmin):
    list_display = [
        'gambar_display', 'nama', 'kategori', 'format_harga_display', 
        'stok', 'status_badge', 'jumlah_terjual', 'aktif'
    ]
    list_filter = [
        'aktif', 'status_stok', 'kategori',
        'produk_digital', 'produk_unggulan',
        'produk_baru', 'dibuat_pada',
    ]
    search_fields = ['nama', 'sku', 'deskripsi', 'tag']
    prepopulated_fields = {'slug': ('nama',)}
    list_editable = ['aktif']
    ordering = ['-dibuat_pada']
    
    inlines = [VariasiProdukInline, UlasanProdukInline]
    
    fieldsets = (
        ('Informasi Dasar', {
            'fields': (
                'nama', 'slug', 'kategori', 'sku', 
                'deskripsi_singkat', 'deskripsi'
            )
        }),
        ('Harga & Diskon', {
            'fields': ('harga', 'persentase_diskon', 'produk_digital')
        }),
        ('Gambar Produk', {
            'fields': ('gambar_utama', 'gambar_2', 'gambar_3', 'gambar_4'),
            'classes': ('collapse',)
        }),
        ('Stok & Status', {
            'fields': ('stok', 'stok_minimum', 'status_stok')
        }),
        ('Fitur & Spesifikasi', {
            'fields': ('fitur', 'spesifikasi'),
            'classes': ('collapse',)
        }),
        ('Informasi Fisik', {
            'fields': ('berat', 'dimensi'),
            'classes': ('collapse',)
        }),
        ('Marketing & SEO', {
            'fields': (
                'produk_unggulan', 'produk_baru', 'tag',
                'meta_title', 'meta_description'
            ),
            'classes': ('collapse',)
        }),
        ('Statistik', {
            'fields': ('rating', 'jumlah_ulasan', 'jumlah_terjual', 'jumlah_dilihat'),
            'classes': ('collapse',)
        }),
        ('Status', {
            'fields': ('aktif', 'dibuat_oleh')
        }),
    )
    
    readonly_fields = ['rating', 'jumlah_ulasan', 'jumlah_terjual', 'jumlah_dilihat']
    
    @display(description="Gambar")
    def gambar_display(self, obj):
        if obj.gambar_utama:
            return format_html(
                '',
                obj.gambar_utama.url
            )
        return '-'
    
    @display(description="Harga", ordering='harga')
    def format_harga_display(self, obj):
        if obj.ada_diskon:
            return format_html(
                '
{}
{} -{}%
',
                obj.format_harga,
                obj.format_harga_diskon,
                obj.persentase_diskon
            )
        return format_html('{}', obj.format_harga)
    
    @display(description="Status")
    def status_badge(self, obj):
        colors = {
            'tersedia': '#10b981',
            'stok_menipis': '#f59e0b',
            'habis': '#ef4444',
            'pre_order': '#3b82f6',
            'tidak_dijual': '#6b7280',
        }
        return format_html(
            '{}',
            colors.get(obj.status_stok, '#6b7280'),
            obj.status_ketersediaan
        )
    
    def save_model(self, request, obj, form, change):
        if not change:
            obj.dibuat_oleh = request.user
        super().save_model(request, obj, form, change)

# [ALL OTHER ADMIN CLASSES CONTINUE - 15 total admin registrations]
# Including: VariasiProduk, UlasanProduk, Pelanggan, Pesanan,
# ItemPesanan, AlamatPengiriman, Transaksi, ProfilPengguna,
# AlamatPelanggan, WishlistPelanggan, KeranjangBelanja,
# KuponDiskon, PenggunaanKupon

from django.urls import path
from . import views
from django.views.generic import TemplateView

urlpatterns = [
    # Authentication routes
    path('login/', views.login_user, name='login'),
    path('logout/', views.logout_user, name='logout'),
    path('register/', views.register_user, name='register'),
    
    # User profile routes
    path('profil/', views.profil_user, name='profil'),
    path('profil/edit/', views.edit_profile, name='edit_profile'),
    path('profil/orders//', views.order_detail, name='order_detail'),
    path('profil/alamat/', views.daftar_alamat, name='daftar_alamat'),
    path('profil/alamat/tambah/', views.tambah_alamat, name='tambah_alamat'),
    path('profil/alamat/edit//', views.edit_alamat, name='edit_alamat'),
    path('profil/wishlist/', views.wishlist_pelanggan, name='wishlist_pelanggan'),

    # Store, cart and checkout routes
    path('', views.store, name="store"),
    path('cart/', views.cart, name="cart"),
    path('checkout/', views.checkout, name="checkout"),
    path('checkout-page/', TemplateView.as_view(template_name="checkout.html"), name='checkout_page'),
    
    # Product routes
    path('product//', views.product_detail, name='product_detail'),
    path('product//', views.detail_produk_slug, name='detail_produk_slug'),
    path('product//review/', views.add_review, name='add_review'),
    path('product//wishlist/', views.toggle_wishlist, name='toggle_wishlist'),
    
    # Category routes
    path('categories/', views.category_list, name='category_list'),
    path('category//', views.category_detail, name='category_detail'),
    
    # Search route
    path('search/', views.cari_produk, name='cari_produk'),
    
    # Coupon route
    path('validate-coupon/', views.validasi_kupon, name='validasi_kupon'),
    
    # API endpoints
    path('create-transaction/', views.create_transaction, name='create_transaction'),
    path('update_item/', views.updateItem, name="update_item"),
    path('process_order/', views.processOrder, name="process_order"),
    
    # Payment callback routes
    path('payment/success/', views.payment_success, name='payment_success'),
    path('payment/error/', views.payment_error, name='payment_error'),
    path('payment/pending/', views.payment_pending, name='payment_pending'),
    path('payment/confirmation/', views.payment_confirmation, name='payment_confirmation'),
    
    # Midtrans webhook
    path('midtrans-notification/', views.midtrans_notification_handler, name='midtrans_notification'),
    
    # Admin routes
    path('admin/laporan/', views.laporan_penjualan, name='laporan_penjualan'),
]