package com.aistudio.bonjuteri.jwlry.ui.screens.admin

import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.horizontalScroll
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
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.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.foundation.shape.RoundedCornerShape
import com.aistudio.bonjuteri.jwlry.ui.theme.LightSurface
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.filled.LocalShipping
import androidx.compose.material.icons.filled.ShoppingBag
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.ExperimentalMaterial3Api
import androidx.compose.material3.FilterChip
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.aistudio.bonjuteri.jwlry.model.Order
import com.aistudio.bonjuteri.jwlry.model.OrderStatus
import com.aistudio.bonjuteri.jwlry.model.PaymentStatus
import com.aistudio.bonjuteri.jwlry.model.Product
import com.aistudio.bonjuteri.jwlry.ui.components.EmptyStateView
import com.aistudio.bonjuteri.jwlry.ui.theme.GoldDark
import com.aistudio.bonjuteri.jwlry.ui.theme.GoldPrimary
import com.aistudio.bonjuteri.jwlry.ui.theme.GoldSubtle
import com.aistudio.bonjuteri.jwlry.ui.theme.MutedGrey
import com.aistudio.bonjuteri.jwlry.ui.theme.OffWhite
import com.aistudio.bonjuteri.jwlry.ui.theme.PrimaryBlack
import com.aistudio.bonjuteri.jwlry.ui.theme.PureWhite
import com.aistudio.bonjuteri.jwlry.ui.theme.SurfaceBorder
import kotlinx.coroutines.launch

private val CARGO_COMPANIES = listOf("Yurtiçi Kargo", "Aras Kargo", "MNG Kargo", "PTT Kargo", "Sürat Kargo", "Kolay Gelsin")

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun AdminOrderScreen(
    orders: List<Order>,
    onUpdateOrderStatus: suspend (String, OrderStatus) -> Result<Unit>,
    onUpdateCargoInfo: suspend (String, String, String) -> Result<Unit>,
    onUpdatePaymentStatus: suspend (String, PaymentStatus) -> Result<Unit>,
    onBackClick: () -> Unit,
    snackbarHostState: SnackbarHostState,
    modifier: Modifier = Modifier
) {
    var filterStatus by remember { mutableStateOf<OrderStatus?>(null) }
    var selectedOrderForDetail by remember { mutableStateOf<Order?>(null) }
    val scope = rememberCoroutineScope()

    val filteredOrders = remember(orders, filterStatus) {
        if (filterStatus == null) orders else orders.filter { it.statusEnum == filterStatus }
    }

    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text("Sipariş Yönetimi (${orders.size})", fontWeight = FontWeight.Bold) },
                navigationIcon = {
                    IconButton(onClick = onBackClick) {
                        Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Geri")
                    }
                },
                colors = TopAppBarDefaults.topAppBarColors(containerColor = PureWhite)
            )
        }
    ) { padding ->
        Column(
            modifier = modifier
                .fillMaxSize()
                .padding(padding)
                .background(OffWhite)
        ) {
            // Status Filter Chips
            Row(
                modifier = Modifier
                    .fillMaxWidth()
                    .horizontalScroll(rememberScrollState())
                    .padding(horizontal = 14.dp, vertical = 8.dp),
                horizontalArrangement = Arrangement.spacedBy(8.dp)
            ) {
                FilterChip(
                    selected = filterStatus == null,
                    onClick = { filterStatus = null },
                    label = { Text("Tümü (${orders.size})") }
                )
                OrderStatus.entries.forEach { status ->
                    val count = orders.count { it.statusEnum == status }
                    FilterChip(
                        selected = filterStatus == status,
                        onClick = { filterStatus = if (filterStatus == status) null else status },
                        label = { Text("${status.displayName} ($count)") }
                    )
                }
            }

            if (filteredOrders.isEmpty()) {
                EmptyStateView(
                    icon = Icons.Filled.ShoppingBag,
                    title = "Sipariş Bulunmuyor",
                    description = "Seçili filtreye uygun sipariş bulunmamaktadır.",
                    modifier = Modifier.fillMaxSize()
                )
            } else {
                LazyColumn(
                    modifier = Modifier
                        .fillMaxSize()
                        .padding(horizontal = 14.dp),
                    verticalArrangement = Arrangement.spacedBy(10.dp)
                ) {
                    items(filteredOrders, key = { it.id }) { order ->
                        Card(
                            modifier = Modifier
                                .fillMaxWidth()
                                .clickable { selectedOrderForDetail = order }
                                .testTag("admin_order_${order.id}"),
                            colors = CardDefaults.cardColors(containerColor = PureWhite),
                            shape = RoundedCornerShape(12.dp),
                            elevation = CardDefaults.cardElevation(defaultElevation = 1.dp)
                        ) {
                            Column(modifier = Modifier.padding(14.dp)) {
                                Row(
                                    modifier = Modifier.fillMaxWidth(),
                                    horizontalArrangement = Arrangement.SpaceBetween,
                                    verticalAlignment = Alignment.CenterVertically
                                ) {
                                    Column {
                                        Text(order.orderNumber, fontWeight = FontWeight.Bold, fontSize = 14.sp)
                                        Text(order.userEmail, color = MutedGrey, fontSize = 11.sp)
                                    }
                                    val status = order.statusEnum
                                    Box(
                                        modifier = Modifier
                                            .background(Color(status.colorHex).copy(alpha = 0.15f), RoundedCornerShape(12.dp))
                                            .padding(horizontal = 10.dp, vertical = 4.dp)
                                    ) {
                                        Text(status.displayName, color = Color(status.colorHex), fontWeight = FontWeight.Bold, fontSize = 11.sp)
                                    }
                                }

                                HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp), color = SurfaceBorder)

                                Row(
                                    modifier = Modifier.fillMaxWidth(),
                                    horizontalArrangement = Arrangement.SpaceBetween
                                ) {
                                    Text("${order.items.size} Çeşit Ürün", color = MutedGrey, fontSize = 12.sp)
                                    Text(order.formattedTotal, fontWeight = FontWeight.Black, fontSize = 14.sp)
                                }

                                if (order.trackingNumber.isNotBlank()) {
                                    Spacer(modifier = Modifier.height(6.dp))
                                    Text(
                                        text = "${order.cargoCompany}: ${order.trackingNumber}",
                                        color = GoldDark,
                                        fontSize = 11.sp,
                                        fontWeight = FontWeight.SemiBold
                                    )
                                }
                            }
                        }
                    }
                }
            }
        }

        // Order Detail & Action Dialog
        if (selectedOrderForDetail != null) {
            val order = selectedOrderForDetail!!
            var selectedStatus by remember { mutableStateOf(order.statusEnum) }
            var cargoCompany by remember { mutableStateOf(order.cargoCompany.ifBlank { CARGO_COMPANIES.first() }) }
            var trackingNumber by remember { mutableStateOf(order.trackingNumber) }
            var selectedPayment by remember { mutableStateOf(order.paymentStatusEnum) }

            AlertDialog(
                onDismissRequest = { selectedOrderForDetail = null },
                title = { Text(order.orderNumber, fontWeight = FontWeight.Bold) },
                text = {
                    Column(
                        modifier = Modifier.verticalScroll(rememberScrollState()),
                        verticalArrangement = Arrangement.spacedBy(10.dp)
                    ) {
                        Text("Müşteri: ${order.userEmail}", fontSize = 12.sp, color = MutedGrey)
                        Text("Adres: ${order.deliveryAddress.fullDisplayAddress}", fontSize = 12.sp, color = MutedGrey)
                        Text("Tutar: ${order.formattedTotal}", fontWeight = FontWeight.Bold, fontSize = 14.sp)

                        HorizontalDivider(color = SurfaceBorder)

                        Text("Sipariş Durumu:", fontWeight = FontWeight.Bold, fontSize = 12.sp)
                        Row(
                            modifier = Modifier.horizontalScroll(rememberScrollState()),
                            horizontalArrangement = Arrangement.spacedBy(6.dp)
                        ) {
                            OrderStatus.entries.forEach { st ->
                                val isSel = selectedStatus == st
                                Box(
                                    modifier = Modifier
                                        .background(if (isSel) PrimaryBlack else LightSurface, RoundedCornerShape(8.dp))
                                        .clickable { selectedStatus = st }
                                        .padding(horizontal = 8.dp, vertical = 6.dp)
                                ) {
                                    Text(st.displayName, color = if (isSel) PureWhite else PrimaryBlack, fontSize = 11.sp)
                                }
                            }
                        }

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

                        Text("Kargo Firması:", fontWeight = FontWeight.Bold, fontSize = 12.sp)
                        Row(
                            modifier = Modifier.horizontalScroll(rememberScrollState()),
                            horizontalArrangement = Arrangement.spacedBy(6.dp)
                        ) {
                            CARGO_COMPANIES.forEach { cmp ->
                                val isSel = cargoCompany == cmp
                                Box(
                                    modifier = Modifier
                                        .background(if (isSel) GoldPrimary else LightSurface, RoundedCornerShape(8.dp))
                                        .clickable { cargoCompany = cmp }
                                        .padding(horizontal = 8.dp, vertical = 6.dp)
                                ) {
                                    Text(cmp, color = if (isSel) PureWhite else PrimaryBlack, fontSize = 11.sp)
                                }
                            }
                        }

                        OutlinedTextField(
                            value = trackingNumber,
                            onValueChange = { trackingNumber = it },
                            label = { Text("Kargo Takip Numarası") },
                            modifier = Modifier.fillMaxWidth().testTag("admin_order_tracking_input"),
                            singleLine = true
                        )

                        Text("Ödeme Durumu:", fontWeight = FontWeight.Bold, fontSize = 12.sp)
                        Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
                            PaymentStatus.entries.forEach { paySt ->
                                val isSel = selectedPayment == paySt
                                Box(
                                    modifier = Modifier
                                        .background(if (isSel) PrimaryBlack else LightSurface, RoundedCornerShape(8.dp))
                                        .clickable { selectedPayment = paySt }
                                        .padding(horizontal = 8.dp, vertical = 6.dp)
                                ) {
                                    Text(paySt.displayName, color = if (isSel) PureWhite else PrimaryBlack, fontSize = 11.sp)
                                }
                            }
                        }
                    }
                },
                confirmButton = {
                    Button(
                        onClick = {
                            val id = order.id
                            selectedOrderForDetail = null
                            scope.launch {
                                onUpdateOrderStatus(id, selectedStatus)
                                onUpdateCargoInfo(id, cargoCompany, trackingNumber)
                                onUpdatePaymentStatus(id, selectedPayment)
                                snackbarHostState.showSnackbar("Sipariş bilgileri güncellendi.")
                            }
                        },
                        colors = ButtonDefaults.buttonColors(containerColor = PrimaryBlack),
                        modifier = Modifier.testTag("admin_save_order_details")
                    ) {
                        Text("Güncelle")
                    }
                },
                dismissButton = {
                    OutlinedButton(onClick = { selectedOrderForDetail = null }) {
                        Text("Kapat")
                    }
                }
            )
        }
    }
}