dependencies {
    implementation(libs.firebase.firestore)
}

plugins {
    alias(libs.plugins.google.gms.google.services)
}

package com.example.demoapp.data.repository.remote

import com.example.demoapp.domain.model.User
import com.example.demoapp.domain.repository.UserRepository
import com.google.firebase.firestore.FirebaseFirestore
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.tasks.await
import jakarta.inject.Inject
import jakarta.inject.Singleton

@Singleton
class UserRepositoryImpl @Inject constructor(
    private val firestore: FirebaseFirestore // Se inyecta una instancia de FirebaseFirestore para interactuar con la base de datos
): UserRepository {

    // Definimos la colección de usuarios donde se almacenarán los datos
    private val collection = firestore.collection("users")

    // StateFlow para observar los cambios en la colección de usuarios
    private val _users = MutableStateFlow<List<User>>(emptyList())
    override val users: StateFlow<List<User>> = _users.asStateFlow()

    init {
        // Escuchar cambios en tiempo real en la colección de usuarios
        collection.addSnapshotListener { snapshot, _ ->
            snapshot?.let {
                // Se actualiza el StateFlow con la lista de usuarios mapeados desde los documentos
                _users.value = it.documents.mapNotNull { snap ->
                    snap.toObject(User::class.java)?.apply { id = snap.id }
                }
            }
        }
    }

    override suspend fun save(user: User) {
        // Agregar un nuevo documento a la colección de usuarios
        collection.add(user).await()
    }

    override suspend fun findById(id: String): User? {
        // Obtener el documento por ID
        val snapshot = collection.document(id).get().await()
        // Se retorna el objeto User si existe, se mapea el documento a un objeto User y se asigna el ID del documento de Firestore
        return snapshot.toObject(User::class.java)?.apply { this.id = snapshot.id }
    }

    override suspend fun login(email: String, password: String): User? {
        // Consultar la colección para encontrar un usuario con el email y password proporcionados
        val snapshot = collection
            .whereEqualTo("email", email)
            .whereEqualTo("password", password)
            .get()
            .await()

        // Si no se encuentra ningún documento, retornar null
        if (snapshot.documents.isEmpty()) {
            return null
        }

        // Retornar el primer usuario encontrado, se mapea el documento a un objeto User y se asigna el ID del documento de Firestore
        return snapshot.documents.first().toObject(User::class.java)?.apply {
            id = snapshot.documents.first().id
        }

    }

    override suspend fun update(user: User) {
        // Se actualiza el documento existente dado su ID con los nuevos datos del usuario
        collection.document(user.id).set(user).await()
    }

    override suspend fun getAll(): List<User> {
        // Obtener todos los documentos de la colección de usuarios
        val snapshot = collection.get().await()
        // Mapear los documentos a objetos User, asignando el ID del documento de Firestore
        return snapshot.documents.mapNotNull {
            it.toObject(User::class.java)?.apply { id = it.id }
        }
    }

}

package com.example.demoapp.domain.model

data class User (
    var id: String = "",
    val name: String = "",
    val city: String = "",
    val address: String = "",
    val email: String = "",
    val password: String = "",
    val phoneNumber: String = "",
    val profilePictureUrl: String = "",
    val role: UserRole = UserRole.USER
)

package com.example.demoapp.domain.repository

import com.example.demoapp.domain.model.User
import kotlinx.coroutines.flow.StateFlow

interface UserRepository {
    val users: StateFlow<List<User>>
    suspend fun save(user: User)
    suspend fun findById(id: String): User?
    suspend fun login(email: String, password: String): User?
    suspend fun update(user: User)
    suspend fun getAll(): List<User>
}

package com.example.demoapp.data.remote.report

import com.example.demoapp.domain.model.Location
import com.example.demoapp.domain.model.Report
import com.example.demoapp.domain.model.ReportStatus
import java.time.LocalDate

// Representación de un Report tal como se guarda en Firestore.
// Todos los campos tienen valor por defecto para garantizar el constructor vacío.
data class ReportDto(
    val id: String = "",
    val title: String = "",
    val description: String = "",
    val latitude: Double = 0.0,
    val longitude: Double = 0.0,
    val status: String = ReportStatus.PENDING.name,
    val type: String = "",
    val photoUrl: String = "",
    val ownerId: String = "",
    val date: String = ""
) {
    // Convierte el DTO (datos de Firestore) al modelo de dominio
    fun toDomain(): Report = Report(
        id = id,
        title = title,
        description = description,
        location = Location(latitude = latitude, longitude = longitude),
        status = runCatching { ReportStatus.valueOf(status) }.getOrDefault(ReportStatus.PENDING),
        type = type,
        photoUrl = photoUrl,
        ownerId = ownerId,
        date = runCatching { LocalDate.parse(date) }.getOrDefault(LocalDate.now())
    )

    companion object {
        // Convierte el modelo de dominio al DTO que se guardará en Firestore
        fun fromDomain(report: Report): ReportDto = ReportDto(
            id = report.id,
            title = report.title,
            description = report.description,
            latitude = report.location.latitude,
            longitude = report.location.longitude,
            status = report.status.name,
            type = report.type,
            photoUrl = report.photoUrl,
            ownerId = report.ownerId,
            date = report.date.toString()
        )
    }
}

package com.example.demoapp.data.repository.remote

import com.example.demoapp.data.remote.report.ReportDto
import com.example.demoapp.domain.model.Report
import com.example.demoapp.domain.repository.ReportRepository
import com.google.firebase.firestore.FirebaseFirestore
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.tasks.await
import jakarta.inject.Inject
import jakarta.inject.Singleton

@Singleton
class ReportRepositoryImpl @Inject constructor(
    private val firestore: FirebaseFirestore
): ReportRepository {

    // Definimos la colección de reportes donde se almacenarán los datos
    private val collection = firestore.collection("reports")

    // StateFlow para observar los cambios en la colección de reportes
    private val _reports = MutableStateFlow<List<Report>>(emptyList())
    override val reports: StateFlow<List<Report>> = _reports.asStateFlow()

    init {
        // Escuchar cambios en tiempo real en la colección de reportes
        collection.addSnapshotListener { snapshot, _ ->
            snapshot?.let {
                // Se mapean los documentos a DTOs y estos al modelo de dominio,
                // ordenando los reportes del más reciente al más antiguo
                _reports.value = it.documents
                    .mapNotNull { snap -> snap.toObject(ReportDto::class.java)?.copy(id = snap.id) }
                    .map { dto -> dto.toDomain() }
                    .sortedByDescending { report -> report.date }
            }
        }
    }

    override suspend fun save(report: Report) {
        // Agregar un nuevo documento a la colección de reportes
        collection.add(ReportDto.fromDomain(report)).await()
    }

    override suspend fun findById(id: String): Report? {
        // Obtener el documento por ID y mapearlo a un objeto Report
        val snapshot = collection.document(id).get().await()
        return snapshot.toObject(ReportDto::class.java)?.copy(id = snapshot.id)?.toDomain()
    }
}

package com.example.demoapp.di

import com.google.firebase.firestore.FirebaseFirestore
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import jakarta.inject.Singleton

@Module
@InstallIn(SingletonComponent::class)
object FirebaseModule {

    @Provides
    @Singleton
    fun provideFirestore(): FirebaseFirestore {
        // Proporciona una instancia singleton de FirebaseFirestore en toda la aplicación
        return FirebaseFirestore.getInstance()
    }
}

@Binds
@Singleton
abstract fun bindReportRepository(
    reportRepositoryImpl: ReportRepositoryImpl
): ReportRepository

@Binds
@Singleton
abstract fun bindUserRepository(
    userRepositoryImpl: UserRepositoryImpl
): UserRepository

package com.example.demoapp.core.util

sealed class RequestResult {
    data class Success(val message: String) : RequestResult()
    data class Failure(val errorMessage: String) : RequestResult()
    object Loading : RequestResult() // Nuevo estado para representar la carga
}

fun login() {
    if (isFormValid) {
        viewModelScope.launch {
            // Indicar que la operación está en curso
            _loginResult.value = RequestResult.Loading
            // El caso de uso autentica y, si tiene éxito, guarda la sesión
            val user = loginUserUseCase(email.value, password.value)
            _loginResult.value = if (user != null) {
                RequestResult.Success(resources.getString(R.string.login_success))
            } else {
                RequestResult.Failure(resources.getString(R.string.login_failure))
            }
        }
    }
}

// Efecto para mostrar el snackbar cuando hay resultado
LaunchedEffect(loginResult) {
    loginResult?.let { result ->
        val message = when (result) {
            is RequestResult.Success -> result.message
            is RequestResult.Failure -> result.errorMessage
            is RequestResult.Loading -> "Cargando..."
        }
        snackbarHostState.showSnackbar(message)
        viewModel.resetLoginResult()
    }
}

fun register(){
    if (isFormValid) {
        viewModelScope.launch {
            // Indicar que la operación está en curso
            _registerResult.value = RequestResult.Loading
            // Llamar a la función de apoyo para crear el usuario
            _registerResult.value = runCatching { create() }
                .fold(
                    onSuccess = { RequestResult.Success("Usuario registrado exitosamente") },
                    onFailure = {
                        RequestResult.Failure(
                            it.message ?: "Error registrando al usuario"
                        )
                    }
                )
        }
    }
}

// Función de apoyo para crear el usuario
suspend fun create() {
        registerUserUseCase(
            // Ya no es necesario generar un ID manualmente, Firestore lo hace automáticamente
            User(
                name = name.value,
                city = city.value,
                address = address.value,
                email = email.value,
                profilePictureUrl = profilePictureUrl.value,
                password = password.value
            )
        )
    }

package com.example.demoapp.features.report.detail

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.demoapp.core.util.RequestResult
import com.example.demoapp.domain.model.Report
import com.example.demoapp.domain.usecase.report.GetReportByIdUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import jakarta.inject.Inject

@HiltViewModel
class ReportDetailViewModel @Inject constructor(
    private val getReportByIdUseCase: GetReportByIdUseCase
) : ViewModel() {

    // StateFlow para manejar el resultado de la solicitud
    private val _detailResult = MutableStateFlow<RequestResult?>(null)
    val detailResult: StateFlow<RequestResult?> = _detailResult.asStateFlow()

    // StateFlow para manejar el reporte actual
    private val _currentReport = MutableStateFlow<Report?>(null)
    val currentReport: StateFlow<Report?> = _currentReport.asStateFlow()

    // Función para encontrar un reporte por su ID
    fun findById(reportId: String) {
        viewModelScope.launch {
            _currentReport.value = null
            _detailResult.value = RequestResult.Loading
            _detailResult.value = runCatching {
                getReportByIdUseCase(reportId)?.also { _currentReport.value = it }
            }.fold(
                onSuccess = { RequestResult.Success("Reporte encontrado") },
                onFailure = { RequestResult.Failure(it.message ?: "Error obteniendo el reporte") }
            )
        }
    }
}

package com.example.demoapp.features.report.detail

@Composable
fun ReportDetailScreen(
    padding: PaddingValues,
    reportId: String,
    reportViewModel: ReportDetailViewModel = hiltViewModel(),
){

    // Se observa el estado del reporte actual desde el ViewModel
    val report by reportViewModel.currentReport.collectAsState()

    // Efecto para cargar los detalles del reporte cuando el reportId cambia (o al iniciar la pantalla)
    LaunchedEffect(reportId) {
        reportViewModel.findById(reportId)
    }

    // Resto del código...

}