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

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.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.lazy.grid.GridCells
import androidx.compose.foundation.lazy.grid.GridItemSpan
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.grid.items
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.FilterList
import androidx.compose.material.icons.outlined.SearchOff
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.FilterChip
import androidx.compose.material3.FilterChipDefaults
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.Text
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.Banner
import com.aistudio.bonjuteri.jwlry.model.Category
import com.aistudio.bonjuteri.jwlry.model.Product
import com.aistudio.bonjuteri.jwlry.ui.components.BannerCarousel
import com.aistudio.bonjuteri.jwlry.ui.components.EmptyStateView
import com.aistudio.bonjuteri.jwlry.ui.components.ProductCard
import com.aistudio.bonjuteri.jwlry.ui.components.SectionHeader
import com.aistudio.bonjuteri.jwlry.ui.theme.GoldPrimary
import com.aistudio.bonjuteri.jwlry.ui.theme.GoldSubtle
import com.aistudio.bonjuteri.jwlry.ui.theme.LightSurface
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

enum class HomeFilter(val label: String) {
    ALL("Tümü"),
    NEW("Yeni Gelenler"),
    BEST_SELLER("Çok Satanlar"),
    FEATURED("Öne Çıkanlar"),
    DISCOUNT("İndirimli")
}

@Composable
fun HomeScreen(
    products: List<Product>,
    categories: List<Category>,
    banners: List<Banner>,
    favoriteProductIds: Set<String>,
    searchQuery: String,
    isLoading: Boolean,
    onProductClick: (Product) -> Unit,
    onFavoriteToggle: (Product) -> Unit,
    onAddToCart: (Product) -> Unit,
    onCategoryClick: (Category) -> Unit,
    snackbarHostState: SnackbarHostState,
    modifier: Modifier = Modifier
) {
    var selectedFilter by remember { mutableStateOf(HomeFilter.ALL) }
    var selectedCategoryName by remember { mutableStateOf<String?>(null) }
    val scope = rememberCoroutineScope()

    // Filter products based on search query, category, and filter tabs
    val filteredProducts = remember(products, searchQuery, selectedFilter, selectedCategoryName) {
        products.filter { p ->
            val matchesSearch = if (searchQuery.isBlank()) {
                true
            } else {
                p.title.contains(searchQuery, ignoreCase = true) ||
                        p.description.contains(searchQuery, ignoreCase = true) ||
                        p.category.contains(searchQuery, ignoreCase = true)
            }

            val matchesCategory = if (selectedCategoryName == null) {
                true
            } else {
                p.category.equals(selectedCategoryName, ignoreCase = true)
            }

            val matchesTab = when (selectedFilter) {
                HomeFilter.ALL -> true
                HomeFilter.NEW -> p.isNew
                HomeFilter.BEST_SELLER -> p.isBestSeller
                HomeFilter.FEATURED -> p.isFeatured
                HomeFilter.DISCOUNT -> p.hasDiscount
            }

            matchesSearch && matchesCategory && matchesTab
        }
    }

    if (isLoading && products.isEmpty()) {
        Box(
            modifier = modifier.fillMaxSize(),
            contentAlignment = Alignment.Center
        ) {
            CircularProgressIndicator(color = GoldPrimary)
        }
        return
    }

    LazyVerticalGrid(
        columns = GridCells.Fixed(2),
        modifier = modifier
            .fillMaxSize()
            .background(OffWhite)
            .testTag("home_products_grid"),
        contentPadding = PaddingValues(bottom = 24.dp),
        horizontalArrangement = Arrangement.spacedBy(10.dp),
        verticalArrangement = Arrangement.spacedBy(10.dp)
    ) {
        // Hero Banners (only if not searching)
        if (searchQuery.isBlank()) {
            item(span = { GridItemSpan(2) }) {
                BannerCarousel(
                    banners = banners,
                    onBannerClick = { /* Banner click */ },
                    modifier = Modifier.padding(top = 8.dp)
                )
            }

            // Categories horizontal bar
            if (categories.isNotEmpty()) {
                item(span = { GridItemSpan(2) }) {
                    Column(modifier = Modifier.fillMaxWidth()) {
                        SectionHeader(
                            title = "Kategoriler",
                            actionText = null
                        )
                        Row(
                            modifier = Modifier
                                .fillMaxWidth()
                                .horizontalScroll(rememberScrollState())
                                .padding(horizontal = 16.dp),
                            horizontalArrangement = Arrangement.spacedBy(8.dp)
                        ) {
                            // "Tümü" category chip
                            FilterChip(
                                selected = selectedCategoryName == null,
                                onClick = { selectedCategoryName = null },
                                label = { Text("Tümü", fontSize = 12.sp, fontWeight = FontWeight.Bold) },
                                colors = FilterChipDefaults.filterChipColors(
                                    selectedContainerColor = PrimaryBlack,
                                    selectedLabelColor = PureWhite,
                                    containerColor = PureWhite,
                                    labelColor = PrimaryBlack
                                ),
                                border = FilterChipDefaults.filterChipBorder(
                                    borderColor = SurfaceBorder,
                                    selectedBorderColor = PrimaryBlack,
                                    enabled = true,
                                    selected = selectedCategoryName == null
                                )
                            )

                            categories.forEach { cat ->
                                val isSelected = selectedCategoryName.equals(cat.name, ignoreCase = true)
                                FilterChip(
                                    selected = isSelected,
                                    onClick = {
                                        selectedCategoryName = if (isSelected) null else cat.name
                                    },
                                    label = { Text(cat.name, fontSize = 12.sp, fontWeight = FontWeight.Bold) },
                                    colors = FilterChipDefaults.filterChipColors(
                                        selectedContainerColor = PrimaryBlack,
                                        selectedLabelColor = PureWhite,
                                        containerColor = PureWhite,
                                        labelColor = PrimaryBlack
                                    ),
                                    border = FilterChipDefaults.filterChipBorder(
                                        borderColor = SurfaceBorder,
                                        selectedBorderColor = PrimaryBlack,
                                        enabled = true,
                                        selected = isSelected
                                    )
                                )
                            }
                        }
                    }
                }
            }

            // Filter Tabs (Yeni Gelenler, Çok Satanlar, Öne Çıkanlar, İndirimli)
            item(span = { GridItemSpan(2) }) {
                Row(
                    modifier = Modifier
                        .fillMaxWidth()
                        .horizontalScroll(rememberScrollState())
                        .padding(horizontal = 16.dp, vertical = 6.dp),
                    horizontalArrangement = Arrangement.spacedBy(8.dp)
                ) {
                    HomeFilter.entries.forEach { filter ->
                        val isSelected = selectedFilter == filter
                        Box(
                            modifier = Modifier
                                .background(
                                    color = if (isSelected) GoldPrimary else PureWhite,
                                    shape = RoundedCornerShape(20.dp)
                                )
                                .clickable { selectedFilter = filter }
                                .padding(horizontal = 14.dp, vertical = 8.dp),
                            contentAlignment = Alignment.Center
                        ) {
                            Text(
                                text = filter.label,
                                color = if (isSelected) PureWhite else PrimaryBlack,
                                fontSize = 12.sp,
                                fontWeight = if (isSelected) FontWeight.Bold else FontWeight.Medium
                            )
                        }
                    }
                }
            }

            // Products section title
            item(span = { GridItemSpan(2) }) {
                SectionHeader(
                    title = when {
                        selectedCategoryName != null -> selectedCategoryName!!
                        selectedFilter != HomeFilter.ALL -> selectedFilter.label
                        else -> "Özel Tasarım Koleksiyonu"
                    },
                    actionText = "${filteredProducts.size} Ürün"
                )
            }
        } else {
            // Search query active header
            item(span = { GridItemSpan(2) }) {
                Row(
                    modifier = Modifier
                        .fillMaxWidth()
                        .padding(horizontal = 16.dp, vertical = 8.dp),
                    verticalAlignment = Alignment.CenterVertically
                ) {
                    Text(
                        text = "\"$searchQuery\" için sonuçlar (${filteredProducts.size} ürün)",
                        style = MaterialTheme.typography.titleMedium.copy(
                            fontWeight = FontWeight.Bold,
                            color = PrimaryBlack
                        )
                    )
                }
            }
        }

        // Empty Products State
        if (filteredProducts.isEmpty()) {
            item(span = { GridItemSpan(2) }) {
                EmptyStateView(
                    icon = Icons.Outlined.SearchOff,
                    title = if (searchQuery.isNotBlank()) "Aramanızla Eşleşen Ürün Bulunamadı" else "Henüz Ürün Eklenmemiş",
                    description = if (searchQuery.isNotBlank())
                        "Lütfen farklı anahtar kelimelerle tekrar arayınız."
                    else
                        "Mağazamızda şu anda aktif ürün bulunmamaktadır. Yönetici panelinden kolayca ürün ekleyebilirsiniz.",
                    actionButtonText = if (selectedCategoryName != null || selectedFilter != HomeFilter.ALL) "Filtreleri Temizle" else null,
                    onActionClick = {
                        selectedCategoryName = null
                        selectedFilter = HomeFilter.ALL
                    }
                )
            }
        } else {
            items(
                items = filteredProducts,
                key = { it.id }
            ) { product ->
                Box(modifier = Modifier.padding(horizontal = 8.dp)) {
                    ProductCard(
                        product = product,
                        isFavorite = favoriteProductIds.contains(product.id),
                        onProductClick = onProductClick,
                        onFavoriteToggle = { prod ->
                            onFavoriteToggle(prod)
                            scope.launch {
                                val isNowFav = !favoriteProductIds.contains(prod.id)
                                snackbarHostState.showSnackbar(
                                    if (isNowFav) "Ürün favorilerinize eklendi" else "Ürün favorilerinizden çıkarıldı"
                                )
                            }
                        },
                        onAddToCart = { prod ->
                            onAddToCart(prod)
                            scope.launch {
                                snackbarHostState.showSnackbar("${prod.title} sepete eklendi!")
                            }
                        }
                    )
                }
            }
        }
    }
}