SupabaseAuthService.swift

import Combine
import Supabase
import SwiftUI

// MARK: - Auth-specific errors

enum RegistrationError: LocalizedError {
    case emailConfirmationRequired

    var errorDescription: String? {
        switch self {
        case .emailConfirmationRequired:
            return "Revisa tu correo para confirmar tu cuenta."
        }
    }
}

// MARK: - Supabase Auth Service

@MainActor
final class SupabaseAuthService: ObservableObject, AuthRepository {
    @Published var currentUser: UserProfile?
    @Published private(set) var isAuthenticated = false
    @Published private(set) var isLoading = false
    @Published private(set) var isInitialLoading = true
    @Published private(set) var errorMessage: String?

    // MARK: - Publishers

    var isAuthenticatedPublisher: AnyPublisher<Bool, Never> {
        $isAuthenticated.eraseToAnyPublisher()
    }

    var isLoadingPublisher: AnyPublisher<Bool, Never> {
        $isLoading.eraseToAnyPublisher()
    }

    var errorMessagePublisher: AnyPublisher<String?, Never> {
        $errorMessage.eraseToAnyPublisher()
    }

    var objectWillChangePublisher: AnyPublisher<Void, Never> {
        objectWillChange.map { _ in () }.eraseToAnyPublisher()
    }

    // MARK: - Init

    init() {
        Task { await restoreSession() }
    }

    // MARK: - Auth actions

    func signIn(email: String, password: String) async -> Result<Void, DMError> {
        isLoading = true
        defer { isLoading = false }
        do {
            let session = try await supabase.auth.signIn(email: email, password: password)
            try await loadProfile(userId: session.user.id)
            return .success(())
        } catch {
            let errorMsg = error.localizedDescription
            errorMessage = errorMsg
            if errorMsg.localizedCaseInsensitiveContains("email not confirmed") ||
                errorMsg.localizedCaseInsensitiveContains("confirm")
            {
                return .failure(.emailConfirmationRequired("Tu correo no está confirmado. Por favor ingresa el código de confirmación."))
            }
            return .failure(.unknown(errorMsg))
        }
    }

    func signUp(
        email: String,
        password: String,
        username: String,
        displayName: String,
        university: String? = nil
    ) async -> Result<Void, DMError> {
        isLoading = true
        defer { isLoading = false }
        do {
            var metadata: [String: AnyJSON] = [
                "username": .string(username),
                "display_name": .string(displayName),
                "is_moderator": .bool(email.lowercased() == "moderador@dailymath.com"),
            ]
            if let university {
                metadata["university"] = .string(university)
            }
            let response = try await supabase.auth.signUp(
                email: email,
                password: password,
                data: metadata
            )
            if response.session != nil {
                // Auto-confirmed — load profile and log in immediately
                try await loadProfile(userId: response.user.id)
                return .success(())
            } else {
                // Email confirmation required — registration succeeded but user must confirm
                return .failure(.emailConfirmationRequired("Revisa tu correo para confirmar tu cuenta."))
            }
        } catch {
            errorMessage = error.localizedDescription
            return .failure(.unknown(error.localizedDescription))
        }
    }

    func signOut() async -> Result<Void, DMError> {
        do {
            try await supabase.auth.signOut()
            currentUser = nil
            isAuthenticated = false
            return .success(())
        } catch {
            return .failure(.unknown(error.localizedDescription))
        }
    }

    func resetPassword(email: String) async -> Result<Void, DMError> {
        do {
            try await supabase.auth.resetPasswordForEmail(email)
            return .success(())
        } catch {
            return .failure(.unknown(error.localizedDescription))
        }
    }

    func deleteAccount() async -> Result<Void, DMError> {
        guard let userId = currentUser?.id else {
            return .failure(.unauthorized)
        }
        do {
            // Delete profile row (cascades to all user data)
            try await supabase
                .from("profiles")
                .delete()
                .eq("id", value: userId.uuidString)
                .execute()
            _ = await signOut()
            return .success(())
        } catch {
            return .failure(.unknown(error.localizedDescription))
        }
    }

    // MARK: - Profile mutation helper (used by repositories to update points etc.)

    func updateCurrentProfile(_ mutation: (inout UserProfile) -> Void) {
        guard var profile = currentUser else { return }
        mutation(&profile)
        currentUser = profile
        Task {
            try? await supabase
                .from("profiles")
                .update([
                    "points": profile.points,
                    "reputation": profile.reputation,
                    "study_streak": profile.studyStreak,
                ])
                .eq("id", value: profile.id.uuidString)
                .execute()
        }
    }

    func checkEmailExists(email: String) async -> Result<Bool, DMError> {
        do {
            let normalized = email.lowercased().trimmingCharacters(in: .whitespaces)
            let profiles: [UserProfile] = try await supabase
                .from("profiles")
                .select()
                .eq("email", value: normalized)
                .execute()
                .value
            return .success(!profiles.isEmpty)
        } catch {
            return .failure(.unknown(error.localizedDescription))
        }
    }

    // MARK: - Private helpers

    private func loadProfile(userId: UUID) async throws {
        let profile: UserProfile = try await supabase
            .from("profiles")
            .select()
            .eq("id", value: userId.uuidString)
            .single()
            .execute()
            .value
        currentUser = profile
        isAuthenticated = true
        errorMessage = nil
    }

    private func restoreSession() async {
        isInitialLoading = true
        isLoading = true
        defer {
            isLoading = false
            isInitialLoading = false
        }
        do {
            let session = try await supabase.auth.session
            try await loadProfile(userId: session.user.id)
        } catch {
            // No active session — stay logged out
            isAuthenticated = false
        }
    }
}