package com.aistudio.bonjuteri.jwlry.data

import android.content.Context
import android.util.Log
import com.aistudio.bonjuteri.jwlry.model.Category
import com.google.firebase.firestore.FirebaseFirestore
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.tasks.await

class CategoryRepository(
    private val firestore: FirebaseFirestore
) {
    companion object {
        private const val TAG = "CategoryRepository"
        const val CATEGORIES_COLLECTION = "categories"

        @Volatile
        private var INSTANCE: CategoryRepository? = null

        fun getInstance(context: Context): CategoryRepository {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: CategoryRepository(
                    FirestoreHelper.getFirestore(context)
                ).also { INSTANCE = it }
            }
        }
    }

    fun observeCategories(onlyActive: Boolean = true): Flow<List<Category>> = callbackFlow {
        val query = if (onlyActive) {
            firestore.collection(CATEGORIES_COLLECTION).whereEqualTo("isActive", true)
        } else {
            firestore.collection(CATEGORIES_COLLECTION)
        }

        val listener = query.addSnapshotListener { snapshot, error ->
            if (error != null) {
                FirestoreHelper.handleFirestoreError(error, "observeCategories", CATEGORIES_COLLECTION)
                trySend(emptyList())
                return@addSnapshotListener
            }
            val list = snapshot?.documents?.mapNotNull { it.toObject(Category::class.java) }
                ?.sortedBy { it.order } ?: emptyList()
            trySend(list)
        }
        awaitClose { listener.remove() }
    }

    suspend fun addCategory(name: String, imageUrl: String, order: Long): Result<Category> {
        val trimmed = name.trim()
        if (trimmed.isBlank()) {
            return Result.failure(IllegalArgumentException("Kategori adı boş olamaz."))
        }
        return try {
            val docRef = firestore.collection(CATEGORIES_COLLECTION).document()
            val category = Category(
                id = docRef.id,
                name = trimmed,
                imageUrl = imageUrl.trim(),
                order = order,
                isActive = true
            )
            docRef.set(category).await()
            Result.success(category)
        } catch (e: Throwable) {
            val msg = FirestoreHelper.handleFirestoreError(e, "addCategory", CATEGORIES_COLLECTION)
            Result.failure(Exception(msg))
        }
    }

    suspend fun updateCategory(category: Category): Result<Category> {
        if (category.name.isBlank()) {
            return Result.failure(IllegalArgumentException("Kategori adı boş olamaz."))
        }
        return try {
            firestore.collection(CATEGORIES_COLLECTION).document(category.id).set(category).await()
            Result.success(category)
        } catch (e: Throwable) {
            val msg = FirestoreHelper.handleFirestoreError(e, "updateCategory", category.id)
            Result.failure(Exception(msg))
        }
    }

    suspend fun deleteCategory(categoryId: String): Result<Unit> {
        return try {
            firestore.collection(CATEGORIES_COLLECTION).document(categoryId).delete().await()
            Result.success(Unit)
        } catch (e: Throwable) {
            val msg = FirestoreHelper.handleFirestoreError(e, "deleteCategory", categoryId)
            Result.failure(Exception(msg))
        }
    }
}