package com.example.ui.customer

import android.content.Intent
import android.net.Uri
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.filled.Call
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.CheckCircle
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.DeliveryDining
import androidx.compose.material.icons.filled.Fastfood
import androidx.compose.material.icons.filled.LocationOn
import androidx.compose.material.icons.filled.Receipt
import androidx.compose.material.icons.filled.Refresh
import androidx.compose.material.icons.filled.Restaurant
import androidx.compose.material.icons.filled.Star
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.OutlinedTextFieldDefaults
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.R
import com.example.data.model.Order
import com.example.data.model.OrderStatus
import com.example.ui.components.VegNonVegBadge
import com.example.ui.theme.AccentGold
import com.example.ui.theme.FreshVegGreen
import com.example.ui.theme.LoveRedPrimary
import com.example.ui.theme.TextPrimary
import com.example.ui.theme.TextSecondary
import com.example.ui.customer.auth.AuthContainer
import com.example.viewmodel.AuthViewModel
import com.example.viewmodel.CustomerNavScreen
import com.example.viewmodel.CustomerViewModel
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale

@Composable
fun OrdersScreen(
    customerViewModel: CustomerViewModel,
    authViewModel: AuthViewModel,
    modifier: Modifier = Modifier
) {
    val user by customerViewModel.currentUser.collectAsState()
    if (!user.isLoggedIn) {
        AuthContainer(
            authViewModel = authViewModel,
            onAuthenticated = {}
        )
        return
    }
    val orders by customerViewModel.allOrders.collectAsState()
    var selectedReceiptOrder by remember { mutableStateOf<Order?>(null) }
    var ratingOrder by remember { mutableStateOf<Order?>(null) }

    Column(
        modifier = modifier
            .fillMaxSize()
            .background(Color(0xFFF8F9FD))
    ) {
        // Top Header
        Surface(
            color = Color.White,
            shadowElevation = 2.dp,
            modifier = Modifier.fillMaxWidth()
        ) {
            Row(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(horizontal = 16.dp, vertical = 12.dp),
                verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                Column {
                    Text(
                        text = "ORDER HISTORY",
                        fontSize = 11.sp,
                        color = TextSecondary,
                        fontWeight = FontWeight.Bold
                    )
                    Text(
                        text = "My Orders",
                        fontSize = 20.sp,
                        fontWeight = FontWeight.Black,
                        color = TextPrimary
                    )
                }

                Surface(
                    color = FreshVegGreen.copy(alpha = 0.15f),
                    shape = RoundedCornerShape(12.dp)
                ) {
                    Text(
                        text = "${orders.size} orders",
                        color = FreshVegGreen,
                        fontWeight = FontWeight.Bold,
                        fontSize = 12.sp,
                        modifier = Modifier.padding(horizontal = 10.dp, vertical = 4.dp)
                    )
                }
            }
        }

        if (orders.isEmpty()) {
            Box(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(32.dp),
                contentAlignment = Alignment.Center
            ) {
                Column(horizontalAlignment = Alignment.CenterHorizontally) {
                    Icon(
                        imageVector = Icons.Default.Receipt,
                        contentDescription = null,
                        tint = Color.LightGray,
                        modifier = Modifier.size(64.dp)
                    )
                    Spacer(modifier = Modifier.height(16.dp))
                    Text(
                        text = "No orders yet",
                        fontSize = 18.sp,
                        fontWeight = FontWeight.Bold,
                        color = TextPrimary
                    )
                    Text(
                        text = "Order delicious food from Love Zone and your orders will show up here.",
                        fontSize = 13.sp,
                        color = TextSecondary,
                        modifier = Modifier.padding(top = 4.dp, bottom = 16.dp)
                    )
                    Button(
                        onClick = { customerViewModel.navigateTo(CustomerNavScreen.Menu) },
                        colors = ButtonDefaults.buttonColors(containerColor = LoveRedPrimary),
                        shape = RoundedCornerShape(10.dp)
                    ) {
                        Text("Order Food Now")
                    }
                }
            }
        } else {
            LazyColumn(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(bottom = 80.dp),
                contentPadding = PaddingValues(16.dp),
                verticalArrangement = Arrangement.spacedBy(14.dp)
            ) {
                items(orders) { order ->
                    OrderCardItem(
                        order = order,
                        onViewReceipt = { selectedReceiptOrder = order },
                        onRepeatOrder = { customerViewModel.repeatOrder(order) },
                        onRateOrder = { ratingOrder = order }
                    )
                }
            }
        }
    }

    // Receipt Dialog
    selectedReceiptOrder?.let { order ->
        OrderReceiptDialog(
            order = order,
            onDismiss = { selectedReceiptOrder = null }
        )
    }

    // Rate Order Dialog
    ratingOrder?.let { order ->
        RateOrderDialog(
            order = order,
            customerViewModel = customerViewModel,
            onDismiss = { ratingOrder = null }
        )
    }
}

@Composable
fun OrderCardItem(
    order: Order,
    onViewReceipt: () -> Unit,
    onRepeatOrder: () -> Unit,
    onRateOrder: () -> Unit
) {
    val dateStr = SimpleDateFormat("dd MMM, hh:mm a", Locale.getDefault()).format(Date(order.timestamp))
    val context = LocalContext.current

    Card(
        shape = RoundedCornerShape(16.dp),
        colors = CardDefaults.cardColors(containerColor = Color.White),
        elevation = CardDefaults.cardElevation(defaultElevation = 1.dp),
        modifier = Modifier.fillMaxWidth().testTag("order_card_${order.orderId}")
    ) {
        Column(modifier = Modifier.padding(14.dp)) {
            // Header Row: Restaurant name + Status badge
            Row(
                modifier = Modifier.fillMaxWidth(),
                verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                Row(verticalAlignment = Alignment.CenterVertically) {
                    Box(
                        modifier = Modifier
                            .size(36.dp)
                            .clip(CircleShape)
                            .background(Color(0xFFFFF1F2)),
                        contentAlignment = Alignment.Center
                    ) {
                        Image(
                            painter = painterResource(id = R.drawable.logo_love_zone),
                            contentDescription = "Logo",
                            modifier = Modifier.size(32.dp).clip(CircleShape)
                        )
                    }
                    Spacer(modifier = Modifier.width(10.dp))
                    Column {
                        Text(
                            text = "Love Zone Restaurant",
                            fontWeight = FontWeight.Bold,
                            fontSize = 15.sp,
                            color = TextPrimary
                        )
                        Text(
                            text = "${order.orderId} • $dateStr",
                            fontSize = 11.sp,
                            color = TextSecondary
                        )
                    }
                }

                OrderStatusBadge(status = order.orderStatus)
            }

            // Live progress tracker for active orders
            if (order.orderStatus != OrderStatus.DELIVERED && order.orderStatus != OrderStatus.CANCELLED) {
                Spacer(modifier = Modifier.height(12.dp))
                LiveOrderTracker(currentStatus = order.orderStatus)
            }

            // Assigned Rider Delivery Info
            if (!order.assignedRiderName.isNullOrBlank()) {
                Spacer(modifier = Modifier.height(10.dp))
                Surface(
                    color = Color(0xFFF1F5F9),
                    shape = RoundedCornerShape(10.dp),
                    modifier = Modifier.fillMaxWidth()
                ) {
                    Row(
                        modifier = Modifier
                            .fillMaxWidth()
                            .padding(horizontal = 12.dp, vertical = 8.dp),
                        verticalAlignment = Alignment.CenterVertically,
                        horizontalArrangement = Arrangement.SpaceBetween
                    ) {
                        Row(
                            verticalAlignment = Alignment.CenterVertically,
                            modifier = Modifier.weight(1f)
                        ) {
                            Box(
                                modifier = Modifier
                                    .size(32.dp)
                                    .clip(CircleShape)
                                    .background(LoveRedPrimary.copy(alpha = 0.12f)),
                                contentAlignment = Alignment.Center
                            ) {
                                Icon(
                                    imageVector = Icons.Default.DeliveryDining,
                                    contentDescription = "Rider",
                                    tint = LoveRedPrimary,
                                    modifier = Modifier.size(18.dp)
                                )
                            }
                            Spacer(modifier = Modifier.width(8.dp))
                            Column {
                                Text(
                                    text = "Rider: ${order.assignedRiderName}",
                                    fontSize = 12.sp,
                                    fontWeight = FontWeight.Bold,
                                    color = TextPrimary
                                )
                                Text(
                                    text = order.assignedRiderVehicle ?: "Kumarghat Delivery Fleet",
                                    fontSize = 10.sp,
                                    color = TextSecondary
                                )
                            }
                        }

                        order.assignedRiderPhone?.let { phone ->
                            Surface(
                                color = FreshVegGreen.copy(alpha = 0.15f),
                                shape = RoundedCornerShape(8.dp),
                                modifier = Modifier.clickable {
                                    val intent = Intent(Intent.ACTION_DIAL, Uri.parse("tel:$phone"))
                                    try { context.startActivity(intent) } catch (_: Exception) {}
                                }
                            ) {
                                Row(
                                    modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
                                    verticalAlignment = Alignment.CenterVertically
                                ) {
                                    Icon(
                                        imageVector = Icons.Default.Call,
                                        contentDescription = "Call Rider",
                                        tint = FreshVegGreen,
                                        modifier = Modifier.size(13.dp)
                                    )
                                    Spacer(modifier = Modifier.width(4.dp))
                                    Text(
                                        text = "Call",
                                        color = FreshVegGreen,
                                        fontWeight = FontWeight.Bold,
                                        fontSize = 11.sp
                                    )
                                }
                            }
                        }
                    }
                }
            }

            HorizontalDivider(color = Color(0xFFF1F5F9), modifier = Modifier.padding(vertical = 10.dp))

            // Items List
            order.items.forEach { item ->
                Row(
                    modifier = Modifier
                        .fillMaxWidth()
                        .padding(vertical = 2.dp),
                    verticalAlignment = Alignment.CenterVertically,
                    horizontalArrangement = Arrangement.SpaceBetween
                ) {
                    Row(
                        verticalAlignment = Alignment.CenterVertically,
                        modifier = Modifier.weight(1f)
                    ) {
                        VegNonVegBadge(isVeg = item.isVeg, size = 12.dp)
                        Spacer(modifier = Modifier.width(6.dp))
                        Text(
                            text = "${item.quantity} x ${item.foodName}",
                            fontSize = 13.sp,
                            color = TextPrimary,
                            maxLines = 1,
                            overflow = TextOverflow.Ellipsis
                        )
                    }
                    Text(
                        text = "₹${(item.price * item.quantity).toInt()}",
                        fontSize = 13.sp,
                        fontWeight = FontWeight.SemiBold,
                        color = TextPrimary
                    )
                }
            }

            HorizontalDivider(color = Color(0xFFF1F5F9), modifier = Modifier.padding(vertical = 8.dp))

            // Grand Total and View Receipt
            Row(
                modifier = Modifier.fillMaxWidth(),
                verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                Column {
                    Text(text = "GRAND TOTAL", fontSize = 9.sp, color = TextSecondary, fontWeight = FontWeight.Bold)
                    Row(verticalAlignment = Alignment.CenterVertically) {
                        Text(
                            text = "₹${order.grandTotal.toInt()}",
                            fontWeight = FontWeight.Black,
                            fontSize = 17.sp,
                            color = LoveRedPrimary
                        )
                        Spacer(modifier = Modifier.width(6.dp))
                        Surface(
                            color = Color(0xFFF1F5F9),
                            shape = RoundedCornerShape(4.dp)
                        ) {
                            Text(
                                text = when (order.paymentMethod) {
                                    "PAYTM" -> "PAYTM"
                                    "GPAY" -> "GPAY"
                                    "PHONEPE" -> "PHONEPE"
                                    "UPI_QR" -> "UPI QR"
                                    else -> "COD"
                                },
                                fontSize = 10.sp,
                                fontWeight = FontWeight.Bold,
                                color = TextSecondary,
                                modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp)
                            )
                        }
                    }
                }

                Text(
                    text = "View Receipt >",
                    color = LoveRedPrimary,
                    fontWeight = FontWeight.Bold,
                    fontSize = 13.sp,
                    modifier = Modifier
                        .clickable(onClick = onViewReceipt)
                        .padding(4.dp)
                        .testTag("view_receipt_${order.orderId}")
                )
            }

            Spacer(modifier = Modifier.height(10.dp))

            // Bottom action buttons: Rate order & Repeat order
            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.spacedBy(10.dp)
            ) {
                OutlinedButton(
                    onClick = onRateOrder,
                    shape = RoundedCornerShape(10.dp),
                    contentPadding = PaddingValues(horizontal = 12.dp, vertical = 6.dp),
                    modifier = Modifier.weight(1f).height(40.dp)
                ) {
                    Icon(Icons.Default.Star, contentDescription = null, tint = AccentGold, modifier = Modifier.size(16.dp))
                    Spacer(modifier = Modifier.width(4.dp))
                    Text(text = "Rate Order", fontSize = 12.sp, color = TextPrimary)
                }

                Button(
                    onClick = onRepeatOrder,
                    shape = RoundedCornerShape(10.dp),
                    colors = ButtonDefaults.buttonColors(containerColor = Color(0xFFFF6D00)),
                    contentPadding = PaddingValues(horizontal = 12.dp, vertical = 6.dp),
                    modifier = Modifier.weight(1f).height(40.dp).testTag("repeat_order_${order.orderId}")
                ) {
                    Icon(Icons.Default.Refresh, contentDescription = null, modifier = Modifier.size(16.dp))
                    Spacer(modifier = Modifier.width(4.dp))
                    Text(text = "REPEAT ORDER", fontSize = 12.sp, fontWeight = FontWeight.Bold)
                }
            }
        }
    }
}

@Composable
fun LiveOrderTracker(currentStatus: OrderStatus) {
    val steps = listOf(
        OrderStatus.PLACED to "Confirmed",
        OrderStatus.PREPARING to "Kitchen",
        OrderStatus.OUT_FOR_DELIVERY to "On the Way",
        OrderStatus.DELIVERED to "Delivered"
    )

    val currentIndex = when (currentStatus) {
        OrderStatus.PLACED -> 0
        OrderStatus.PREPARING -> 1
        OrderStatus.OUT_FOR_DELIVERY -> 2
        OrderStatus.DELIVERED -> 3
        OrderStatus.CANCELLED -> -1
    }

    Surface(
        color = Color(0xFFFFF7ED),
        shape = RoundedCornerShape(10.dp),
        modifier = Modifier.fillMaxWidth()
    ) {
        Row(
            modifier = Modifier
                .fillMaxWidth()
                .padding(10.dp),
            horizontalArrangement = Arrangement.SpaceBetween,
            verticalAlignment = Alignment.CenterVertically
        ) {
            steps.forEachIndexed { index, (_, label) ->
                val isDone = index <= currentIndex
                val isCurrent = index == currentIndex

                Column(horizontalAlignment = Alignment.CenterHorizontally) {
                    Box(
                        modifier = Modifier
                            .size(24.dp)
                            .background(
                                color = if (isDone) LoveRedPrimary else Color(0xFFCBD5E1),
                                shape = CircleShape
                            ),
                        contentAlignment = Alignment.Center
                    ) {
                        if (isDone) {
                            Icon(Icons.Default.Check, contentDescription = null, tint = Color.White, modifier = Modifier.size(14.dp))
                        }
                    }
                    Spacer(modifier = Modifier.height(4.dp))
                    Text(
                        text = label,
                        fontSize = 10.sp,
                        fontWeight = if (isCurrent) FontWeight.Bold else FontWeight.Normal,
                        color = if (isDone) LoveRedPrimary else Color.Gray
                    )
                }
            }
        }
    }
}

@Composable
fun OrderStatusBadge(status: OrderStatus) {
    val (bgColor, textColor, icon) = when (status) {
        OrderStatus.DELIVERED -> Triple(Color(0xFFE8F5E9), FreshVegGreen, Icons.Default.CheckCircle)
        OrderStatus.PREPARING -> Triple(Color(0xFFFFF3E0), Color(0xFFE65100), Icons.Default.Restaurant)
        OrderStatus.OUT_FOR_DELIVERY -> Triple(Color(0xFFE1F5FE), Color(0xFF0288D1), Icons.Default.DeliveryDining)
        OrderStatus.PLACED -> Triple(Color(0xFFF3E5F5), Color(0xFF7B1FA2), Icons.Default.Check)
        OrderStatus.CANCELLED -> Triple(Color(0xFFFFEBEE), Color(0xFFC62828), Icons.Default.Close)
    }

    Surface(
        color = bgColor,
        shape = RoundedCornerShape(12.dp)
    ) {
        Row(
            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
            verticalAlignment = Alignment.CenterVertically
        ) {
            Icon(imageVector = icon, contentDescription = null, tint = textColor, modifier = Modifier.size(13.dp))
            Spacer(modifier = Modifier.width(4.dp))
            Text(
                text = status.label,
                color = textColor,
                fontSize = 11.sp,
                fontWeight = FontWeight.Bold
            )
        }
    }
}

@Composable
fun OrderReceiptDialog(
    order: Order,
    onDismiss: () -> Unit
) {
    val dateStr = SimpleDateFormat("dd MMM yyyy, hh:mm a", Locale.getDefault()).format(Date(order.timestamp))

    AlertDialog(
        onDismissRequest = onDismiss,
        title = {
            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween,
                verticalAlignment = Alignment.CenterVertically
            ) {
                Text(text = "Order Receipt", fontWeight = FontWeight.Bold, fontSize = 18.sp)
                IconButton(onClick = onDismiss) {
                    Icon(Icons.Default.Close, contentDescription = "Close")
                }
            }
        },
        text = {
            Column(modifier = Modifier.fillMaxWidth()) {
                Text(text = "Love Zone Restaurant", fontWeight = FontWeight.Bold, color = LoveRedPrimary, fontSize = 14.sp)
                Text(text = "Order ID: ${order.orderId}", fontSize = 12.sp, color = TextSecondary)
                Text(text = "Date: $dateStr", fontSize = 12.sp, color = TextSecondary)
                Text(text = "Delivered to: ${order.deliveryAddress}", fontSize = 12.sp, color = TextSecondary)

                HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))

                order.items.forEach { item ->
                    Row(
                        modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp),
                        horizontalArrangement = Arrangement.SpaceBetween
                    ) {
                        Text(text = "${item.quantity} x ${item.foodName}", fontSize = 12.sp, modifier = Modifier.weight(1f))
                        Text(text = "₹${(item.price * item.quantity).toInt()}", fontSize = 12.sp, fontWeight = FontWeight.SemiBold)
                    }
                }

                HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))

                Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
                    Text(text = "Item Total", fontSize = 12.sp, color = TextSecondary)
                    Text(text = "₹${order.itemTotal.toInt()}", fontSize = 12.sp)
                }
                Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
                    Text(text = "Delivery Fee", fontSize = 12.sp, color = TextSecondary)
                    Text(text = if (order.deliveryFee == 0.0) "FREE" else "₹${order.deliveryFee.toInt()}", fontSize = 12.sp)
                }
                if (order.discount > 0) {
                    Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
                        Text(text = "Discount", fontSize = 12.sp, color = LoveRedPrimary)
                        Text(text = "-₹${order.discount.toInt()}", fontSize = 12.sp, color = LoveRedPrimary)
                    }
                }

                HorizontalDivider(modifier = Modifier.padding(vertical = 6.dp))

                Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
                    Text(text = "Grand Total Paid", fontWeight = FontWeight.Bold, fontSize = 14.sp)
                    Text(text = "₹${order.grandTotal.toInt()}", fontWeight = FontWeight.Bold, fontSize = 15.sp, color = LoveRedPrimary)
                }

                Text(
                    text = "Payment: ${when(order.paymentMethod) {
                        "PAYTM" -> "Paytm Online (${order.upiTransactionId})"
                        "GPAY" -> "Google Pay (${order.upiTransactionId})"
                        "PHONEPE" -> "PhonePe (${order.upiTransactionId})"
                        "UPI_QR" -> "Online UPI (${order.upiTransactionId})"
                        else -> "Cash on Delivery (COD)"
                    }}",
                    fontSize = 11.sp,
                    color = TextSecondary,
                    modifier = Modifier.padding(top = 4.dp)
                )

                if (!order.assignedRiderName.isNullOrBlank()) {
                    Text(
                        text = "Assigned Rider: ${order.assignedRiderName} (${order.assignedRiderPhone ?: "Kumarghat Fleet"})",
                        fontSize = 11.sp,
                        fontWeight = FontWeight.SemiBold,
                        color = FreshVegGreen,
                        modifier = Modifier.padding(top = 2.dp)
                    )
                }
            }
        },
        confirmButton = {
            Button(
                onClick = onDismiss,
                colors = ButtonDefaults.buttonColors(containerColor = LoveRedPrimary)
            ) {
                Text("Close")
            }
        }
    )
}

@Composable
fun RateOrderDialog(
    order: Order,
    customerViewModel: CustomerViewModel,
    onDismiss: () -> Unit
) {
    val allFoodItems by customerViewModel.allFoodItems.collectAsState()
    var selectedItemIndex by remember { mutableStateOf(0) }
    var ratingState by remember { mutableStateOf(5) }
    var reviewTextInput by remember { mutableStateOf("") }
    var submitted by remember { mutableStateOf(false) }

    val currentItem = order.items.getOrNull(selectedItemIndex)
    val matchedFoodItem = remember(currentItem, allFoodItems) {
        if (currentItem != null) allFoodItems.find { it.name.equals(currentItem.foodName, ignoreCase = true) } else null
    }

    AlertDialog(
        onDismissRequest = onDismiss,
        title = { Text(text = "Rate & Review Food", fontWeight = FontWeight.Bold, fontSize = 18.sp) },
        text = {
            if (submitted) {
                Column(horizontalAlignment = Alignment.CenterHorizontally, modifier = Modifier.fillMaxWidth()) {
                    Text("Thank you for your rating & written review! ❤️", color = FreshVegGreen, fontWeight = FontWeight.Bold)
                    Spacer(modifier = Modifier.height(6.dp))
                    Text("Your review is now live and visible in the Admin Panel and on the dish page.", fontSize = 12.sp, color = TextSecondary)
                }
            } else if (order.items.isNotEmpty()) {
                Column(modifier = Modifier.fillMaxWidth()) {
                    Text("Select Dish to Rate:", fontSize = 12.sp, fontWeight = FontWeight.Bold, color = TextSecondary)
                    Spacer(modifier = Modifier.height(6.dp))

                    Row(
                        modifier = Modifier.fillMaxWidth(),
                        horizontalArrangement = Arrangement.spacedBy(6.dp)
                    ) {
                        order.items.forEachIndexed { index, item ->
                            Surface(
                                color = if (selectedItemIndex == index) LoveRedPrimary else Color(0xFFF1F5F9),
                                shape = RoundedCornerShape(8.dp),
                                modifier = Modifier.clickable { selectedItemIndex = index }
                            ) {
                                Text(
                                    text = item.foodName,
                                    fontSize = 11.sp,
                                    fontWeight = FontWeight.Bold,
                                    color = if (selectedItemIndex == index) Color.White else TextPrimary,
                                    modifier = Modifier.padding(horizontal = 8.dp, vertical = 5.dp),
                                    maxLines = 1
                                )
                            }
                        }
                    }

                    Spacer(modifier = Modifier.height(14.dp))
                    Text("Star Rating:", fontSize = 12.sp, color = TextSecondary)
                    Spacer(modifier = Modifier.height(4.dp))

                    Row(
                        horizontalArrangement = Arrangement.Center,
                        modifier = Modifier.fillMaxWidth()
                    ) {
                        for (i in 1..5) {
                            Icon(
                                imageVector = Icons.Default.Star,
                                contentDescription = "$i Stars",
                                tint = if (i <= ratingState) AccentGold else Color.LightGray,
                                modifier = Modifier
                                    .size(36.dp)
                                    .clickable { ratingState = i }
                                    .padding(2.dp)
                            )
                        }
                    }

                    Spacer(modifier = Modifier.height(12.dp))
                    Text("Write Feedback (\"Kya likh kar rating kiya hai\"):", fontSize = 12.sp, fontWeight = FontWeight.Medium, color = TextSecondary)
                    Spacer(modifier = Modifier.height(6.dp))

                    // Black text color for typed input
                    OutlinedTextField(
                        value = reviewTextInput,
                        onValueChange = { reviewTextInput = it },
                        placeholder = { Text("e.g. Delicious biryani, super fresh and spicy!") },
                        colors = OutlinedTextFieldDefaults.colors(
                            focusedTextColor = Color.Black,
                            unfocusedTextColor = Color.Black,
                            focusedBorderColor = LoveRedPrimary,
                            unfocusedBorderColor = Color.LightGray,
                            focusedContainerColor = Color(0xFFFAFAFA),
                            unfocusedContainerColor = Color(0xFFFAFAFA)
                        ),
                        shape = RoundedCornerShape(10.dp),
                        modifier = Modifier
                            .fillMaxWidth()
                            .height(90.dp)
                            .testTag("rate_dialog_comment_input"),
                        maxLines = 3
                    )
                }
            }
        },
        confirmButton = {
            Button(
                onClick = {
                    if (submitted) {
                        onDismiss()
                    } else if (currentItem != null) {
                        val foodId = matchedFoodItem?.id ?: 1L
                        customerViewModel.submitFoodReview(
                            foodItemId = foodId,
                            foodName = currentItem.foodName,
                            rating = ratingState.toFloat(),
                            reviewText = reviewTextInput.ifBlank { "Great taste and quality!" },
                            onSuccess = { submitted = true }
                        )
                    }
                },
                colors = ButtonDefaults.buttonColors(containerColor = LoveRedPrimary),
                shape = RoundedCornerShape(10.dp),
                modifier = Modifier.testTag("submit_rate_order_btn")
            ) {
                Text(if (submitted) "Done" else "Submit Rating & Review")
            }
        },
        dismissButton = {
            if (!submitted) {
                TextButton(onClick = onDismiss) {
                    Text("Cancel", color = TextSecondary)
                }
            }
        }
    )
}