package com.aistudio.bonjuteri.jwlry.data

import android.content.Context
import android.util.Log
import com.aistudio.bonjuteri.jwlry.model.Address
import com.google.firebase.Timestamp
import com.google.firebase.auth.FirebaseAuth
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 AddressRepository(
    private val firestore: FirebaseFirestore,
    private val auth: FirebaseAuth
) {
    companion object {
        private const val TAG = "AddressRepository"

        @Volatile
        private var INSTANCE: AddressRepository? = null

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

    private fun requireUserId(): String {
        return auth.currentUser?.uid ?: throw IllegalStateException("Adres yönetimi için giriş yapmalısınız.")
    }

    fun observeAddresses(): Flow<List<Address>> = callbackFlow {
        val uid = auth.currentUser?.uid
        if (uid == null) {
            trySend(emptyList())
            close()
            return@callbackFlow
        }

        val addressesRef = firestore.collection("users").document(uid).collection("addresses")
        val listener = addressesRef.addSnapshotListener { snapshot, error ->
            if (error != null) {
                FirestoreHelper.handleFirestoreError(error, "observeAddresses", addressesRef.path)
                trySend(emptyList())
                return@addSnapshotListener
            }
            val list = snapshot?.documents?.mapNotNull { it.toObject(Address::class.java) } ?: emptyList()
            trySend(list)
        }
        awaitClose { listener.remove() }
    }

    suspend fun saveAddress(address: Address): Result<Address> {
        val trimmedFullName = address.fullName.trim()
        val trimmedPhone = address.phone.trim()
        val trimmedCity = address.city.trim()
        val trimmedDistrict = address.district.trim()
        val trimmedFullAddress = address.fullAddress.trim()

        if (trimmedFullName.isBlank()) {
            return Result.failure(IllegalArgumentException("Ad ve soyad alanı boş bırakılamaz."))
        }
        if (trimmedPhone.isBlank()) {
            return Result.failure(IllegalArgumentException("Telefon numarası gereklidir."))
        }
        if (trimmedCity.isBlank()) {
            return Result.failure(IllegalArgumentException("Lütfen il giriniz."))
        }
        if (trimmedDistrict.isBlank()) {
            return Result.failure(IllegalArgumentException("Lütfen ilçe giriniz."))
        }
        if (trimmedFullAddress.isBlank()) {
            return Result.failure(IllegalArgumentException("Lütfen açık adres giriniz."))
        }

        return try {
            val uid = requireUserId()
            val collectionRef = firestore.collection("users").document(uid).collection("addresses")
            val docRef = if (address.id.isNotBlank()) collectionRef.document(address.id) else collectionRef.document()

            val toSave = address.copy(
                id = docRef.id,
                fullName = trimmedFullName,
                phone = trimmedPhone,
                city = trimmedCity,
                district = trimmedDistrict,
                neighborhood = address.neighborhood.trim(),
                fullAddress = trimmedFullAddress,
                postalCode = address.postalCode.trim(),
                title = address.title.trim().ifBlank { "Adresim" },
                createdAt = address.createdAt ?: Timestamp.now()
            )

            docRef.set(toSave).await()
            Result.success(toSave)
        } catch (e: Throwable) {
            Log.e(TAG, "Adres kaydetme hatası: ${e.message}", e)
            Result.failure(Exception(e.localizedMessage ?: "Adres kaydedilemedi."))
        }
    }

    suspend fun deleteAddress(addressId: String): Result<Unit> {
        return try {
            val uid = requireUserId()
            firestore.collection("users").document(uid)
                .collection("addresses").document(addressId)
                .delete()
                .await()
            Result.success(Unit)
        } catch (e: Throwable) {
            Result.failure(Exception(e.localizedMessage ?: "Adres silinemedi."))
        }
    }
}