Review Prompt

import Foundation

/// Conditions that must be met before showing a review prompt.
///
/// Configure these thresholds based on your app's usage patterns.
/// More engaged users are more likely to leave positive reviews.
struct ReviewPromptCondition {

    /// Minimum number of app sessions before prompting.
    /// Default: 3 (user has returned multiple times)
    let minimumSessions: Int

    /// Minimum days since first launch before prompting.
    /// Default: 3 (user has had time to evaluate)
    let minimumDays: Int

    /// Minimum positive actions before prompting.
    /// Default: 5 (user has accomplished things)
    let minimumPositiveActions: Int

    /// Minimum days between review prompts.
    /// Default: 60 (Apple limits to 3/year anyway)
    let cooldownDays: Int

    /// Default conditions suitable for most apps.
    static let `default` = ReviewPromptCondition(
        minimumSessions: 3,
        minimumDays: 3,
        minimumPositiveActions: 5,
        cooldownDays: 60
    )

    /// More conservative conditions for apps with longer engagement cycles.
    static let conservative = ReviewPromptCondition(
        minimumSessions: 5,
        minimumDays: 7,
        minimumPositiveActions: 10,
        cooldownDays: 90
    )

    /// More aggressive conditions for apps with quick value delivery.
    /// Use with caution - may annoy users if value isn't immediately clear.
    static let eager = ReviewPromptCondition(
        minimumSessions: 2,
        minimumDays: 1,
        minimumPositiveActions: 3,
        cooldownDays: 45
    )
}

// MARK: - Condition Checking

extension ReviewPromptCondition {

    /// Check if all conditions are met.
    func isSatisfied(
        sessions: Int,
        daysSinceInstall: Int,
        positiveActions: Int,
        daysSinceLastPrompt: Int?
    ) -> Bool {
        // Check minimum thresholds
        guard sessions >= minimumSessions else { return false }
        guard daysSinceInstall >= minimumDays else { return false }
        guard positiveActions >= minimumPositiveActions else { return false }

        // Check cooldown
        if let daysSinceLastPrompt = daysSinceLastPrompt {
            guard daysSinceLastPrompt >= cooldownDays else { return false }
        }

        return true
    }
}

import StoreKit
#if canImport(UIKit)
import UIKit
#endif
#if canImport(AppKit)
import AppKit
#endif

/// Manages App Store review prompts with smart timing.
///
/// Usage:
/// ```swift
/// // On app launch/foreground
/// ReviewPromptManager.shared.incrementSession()
///
/// // After positive actions (task completion, etc.)
/// ReviewPromptManager.shared.recordPositiveAction()
/// ReviewPromptManager.shared.requestReviewIfAppropriate()
/// ```
///
/// Configure conditions by setting `ReviewPromptManager.shared.conditions`.
final class ReviewPromptManager {

    // MARK: - Singleton

    static let shared = ReviewPromptManager()

    private init() {}

    // MARK: - Configuration

    /// Conditions that must be met before showing a prompt.
    var conditions = ReviewPromptCondition.default

    #if DEBUG
    /// Set to `true` to always show prompt (debug only).
    var debugAlwaysShow = false
    #endif

    // MARK: - Session Tracking

    /// Increment session count. Call on app launch or foreground.
    func incrementSession() {
        ReviewPromptStorage.incrementSession()

        // Initialize install date on first session
        _ = ReviewPromptStorage.installDate
    }

    // MARK: - Action Tracking

    /// Record a positive user action.
    /// Call when user completes a task, achieves a goal, etc.
    func recordPositiveAction() {
        ReviewPromptStorage.recordPositiveAction()
    }

    // MARK: - Review Request

    /// Request a review if all conditions are met.
    ///
    /// Call this after positive actions, not on every interaction.
    /// The system decides whether to actually show the prompt.
    func requestReviewIfAppropriate() {
        #if DEBUG
        if debugAlwaysShow {
            requestReview()
            return
        }
        #endif

        guard shouldRequestReview() else { return }

        requestReview()
        ReviewPromptStorage.recordPromptShown()
    }

    /// Check if conditions are met for requesting a review.
    func shouldRequestReview() -> Bool {
        // Check platform eligibility first
        guard isAppStoreVersion() else { return false }

        return conditions.isSatisfied(
            sessions: ReviewPromptStorage.sessionCount,
            daysSinceInstall: ReviewPromptStorage.daysSinceInstall,
            positiveActions: ReviewPromptStorage.positiveActionCount,
            daysSinceLastPrompt: ReviewPromptStorage.daysSinceLastPrompt
        )
    }

    // MARK: - Platform Detection

    /// Check if app is running from App Store (not dev/TestFlight).
    private func isAppStoreVersion() -> Bool {
        #if DEBUG
        // Always allow in debug for testing
        return true
        #else
        // Check for App Store receipt
        guard let receiptURL = Bundle.main.appStoreReceiptURL else { return false }
        let receiptExists = FileManager.default.fileExists(atPath: receiptURL.path)

        #if os(macOS)
        // On macOS, sandboxReceipt indicates development/TestFlight
        if receiptURL.lastPathComponent == "sandboxReceipt" {
            return false
        }
        #endif

        return receiptExists
        #endif
    }

    // MARK: - Review Request Implementation

    private func requestReview() {
        #if os(iOS)
        requestReviewiOS()
        #elseif os(macOS)
        requestReviewmacOS()
        #endif
    }

    #if os(iOS)
    private func requestReviewiOS() {
        if let scene = UIApplication.shared.connectedScenes
            .first(where: { $0.activationState == .foregroundActive }) as? UIWindowScene {
            SKStoreReviewController.requestReview(in: scene)
        }
    }
    #endif

    #if os(macOS)
    private func requestReviewmacOS() {
        SKStoreReviewController.requestReview()
    }
    #endif

    // MARK: - Alternative: Direct App Store Link

    /// Open App Store page for writing a review.
    /// Use for macOS direct distribution or custom UI.
    ///
    /// - Parameter appID: Your App Store app ID
    func openAppStoreReviewPage(appID: String) {
        guard let url = URL(string: "https://apps.apple.com/app/id\(appID)?action=write-review") else {
            return
        }

        #if os(iOS)
        UIApplication.shared.open(url)
        #elseif os(macOS)
        NSWorkspace.shared.open(url)
        #endif
    }

    // MARK: - Debug/Testing

    /// Reset all tracking data. Use for testing.
    func reset() {
        ReviewPromptStorage.reset()
    }

    /// Get current tracking stats for debugging.
    var debugStats: String {
        """
        Sessions: \(ReviewPromptStorage.sessionCount)
        Days since install: \(ReviewPromptStorage.daysSinceInstall)
        Positive actions: \(ReviewPromptStorage.positiveActionCount)
        Days since last prompt: \(ReviewPromptStorage.daysSinceLastPrompt.map(String.init) ?? "never")
        Should prompt: \(shouldRequestReview())
        """
    }
}

// MARK: - SwiftUI Integration

import SwiftUI

extension View {

    /// Track session on view appear and request review if appropriate.
    ///
    /// Usage:
    /// ```swift
    /// ContentView()
    ///     .trackSessionAndRequestReview()
    /// ```
    func trackSessionAndRequestReview() -> some View {
        onAppear {
            ReviewPromptManager.shared.incrementSession()
        }
    }

    /// Request review after a delay if conditions are met.
    /// Use after positive actions.
    ///
    /// - Parameter delay: Seconds to wait before requesting (default: 1.0)
    func requestReviewIfAppropriate(delay: TimeInterval = 1.0) -> some View {
        onAppear {
            DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
                ReviewPromptManager.shared.requestReviewIfAppropriate()
            }
        }
    }
}

import Foundation

/// Persistent storage for review prompt tracking.
///
/// Tracks session count, install date, positive actions, and last prompt date
/// to determine when to show review prompts.
enum ReviewPromptStorage {

    // MARK: - Keys

    private enum Keys {
        static let sessionCount = "reviewPrompt.sessionCount"
        static let installDate = "reviewPrompt.installDate"
        static let positiveActionCount = "reviewPrompt.positiveActionCount"
        static let lastPromptDate = "reviewPrompt.lastPromptDate"
    }

    // MARK: - Session Count

    /// Number of app sessions (launches/foreground events).
    static var sessionCount: Int {
        get { UserDefaults.standard.integer(forKey: Keys.sessionCount) }
        set { UserDefaults.standard.set(newValue, forKey: Keys.sessionCount) }
    }

    /// Increment session count. Call on app launch or foreground.
    static func incrementSession() {
        sessionCount += 1
    }

    // MARK: - Install Date

    /// Date of first app launch.
    static var installDate: Date {
        get {
            if let date = UserDefaults.standard.object(forKey: Keys.installDate) as? Date {
                return date
            }
            // First access - set to now
            let now = Date()
            UserDefaults.standard.set(now, forKey: Keys.installDate)
            return now
        }
    }

    /// Days since first launch.
    static var daysSinceInstall: Int {
        Calendar.current.dateComponents([.day], from: installDate, to: Date()).day ?? 0
    }

    // MARK: - Positive Actions

    /// Count of positive user actions (task completions, etc.).
    static var positiveActionCount: Int {
        get { UserDefaults.standard.integer(forKey: Keys.positiveActionCount) }
        set { UserDefaults.standard.set(newValue, forKey: Keys.positiveActionCount) }
    }

    /// Record a positive action. Call when user accomplishes something.
    static func recordPositiveAction() {
        positiveActionCount += 1
    }

    // MARK: - Last Prompt Date

    /// Date of last review prompt attempt.
    static var lastPromptDate: Date? {
        get { UserDefaults.standard.object(forKey: Keys.lastPromptDate) as? Date }
        set { UserDefaults.standard.set(newValue, forKey: Keys.lastPromptDate) }
    }

    /// Days since last prompt (nil if never prompted).
    static var daysSinceLastPrompt: Int? {
        guard let lastDate = lastPromptDate else { return nil }
        return Calendar.current.dateComponents([.day], from: lastDate, to: Date()).day
    }

    /// Record that a prompt was shown.
    static func recordPromptShown() {
        lastPromptDate = Date()
    }

    // MARK: - Reset (Testing)

    /// Reset all tracking data. Use for testing.
    static func reset() {
        UserDefaults.standard.removeObject(forKey: Keys.sessionCount)
        UserDefaults.standard.removeObject(forKey: Keys.installDate)
        UserDefaults.standard.removeObject(forKey: Keys.positiveActionCount)
        UserDefaults.standard.removeObject(forKey: Keys.lastPromptDate)
    }
}