iOS WebView Embed Integration

struct CancellationView: View {
    @State private var showingEncore = false
    @Environment(\.dismiss) private var dismiss
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Cancel Subscription")
                .font(.title)
            
            Text("Are you sure you want to cancel?")
            
            Button("Show Me Offers First") {
                showingEncore = true
            }
            .buttonStyle(.borderedProminent)
            
            Button("Cancel Anyway", role: .destructive) {
                cancelSubscription()
            }
        }
        .sheet(isPresented: $showingEncore) {
            EncoreWebView(
                apiKey: "pk_live_...",
                userId: currentUser.id,
                attributes: [
                    "subscriptionTier": "premium",
                    "cancelReason": "price"
                ]
            )
        }
    }
    
    func cancelSubscription() {
        // Your cancellation logic
        dismiss()
    }
}

struct PremiumFeatureView: View {
    @State private var showingEncore = false
    let isPremium: Bool
    
    var body: some View {
        Group {
            if isPremium {
                PremiumContent()
            } else {
                VStack(spacing: 20) {
                    Image(systemName: "lock.fill")
                        .font(.largeTitle)
                    
                    Text("Premium Feature")
                        .font(.title)
                    
                    Text("Unlock this and more by completing an offer")
                        .multilineTextAlignment(.center)
                    
                    Button("Unlock Now") {
                        showingEncore = true
                    }
                    .buttonStyle(.borderedProminent)
                }
                .sheet(isPresented: $showingEncore) {
                    EncoreWebView(
                        apiKey: "pk_live_...",
                        userId: currentUser.id
                    )
                }
            }
        }
    }
}

struct SettingsView: View {
    @State private var showingEncore = false
    
    var body: some View {
        List {
            Section("Account") {
                // Your settings...
            }
            
            Section("Rewards") {
                Button {
                    showingEncore = true
                } label: {
                    Label("Unlock Premium Features", systemImage: "gift")
                }
            }
        }
        .sheet(isPresented: $showingEncore) {
            EncoreWebView(
                apiKey: "pk_live_...",
                userId: currentUser.id
            )
        }
    }
}

struct ContentView: View {
    @State private var showingEncore = false
    
    var body: some View {
        Button("Show Offers") {
            showingEncore = true
        }
        .sheet(isPresented: $showingEncore) {
            EncoreWebView(
                apiKey: "pk_live_...",
                userId: currentUser.id,
                onEntitlementGranted: { entitlement in
                    handleEntitlement(entitlement)
                }
            )
        }
    }
    
    func handleEntitlement(_ entitlement: EncoreEntitlement) {
        switch entitlement.type {
        case .freeTrial:
            let days = entitlement.value ?? 7
            print("✅ Granted \(days)-day free trial")
            enableFreeTrial(days: days)
            
        case .discount:
            let percent = entitlement.value ?? 20
            print("✅ Granted \(percent)% discount")
            applyDiscount(percent: percent)
            
        case .credit:
            let amount = entitlement.value ?? 10
            print("✅ Granted $\(amount) credit")
            addAccountCredit(amount: amount)
        }
    }
}

struct PremiumUnlockView: View {
    @State private var showingEncore = false
    @State private var isPremium = false
    @State private var showSuccess = false
    @State private var successMessage = ""
    
    var body: some View {
        VStack(spacing: 20) {
            if isPremium {
                VStack {
                    Image(systemName: "checkmark.circle.fill")
                        .font(.system(size: 60))
                        .foregroundColor(.green)
                    Text("Premium Active!")
                        .font(.title)
                    PremiumContent()
                }
            } else {
                VStack {
                    Image(systemName: "lock.fill")
                        .font(.largeTitle)
                    Text("Unlock Premium Features")
                        .font(.title2)
                    Text("Complete an offer to get instant access")
                        .foregroundColor(.secondary)
                    
                    Button("View Offers") {
                        showingEncore = true
                    }
                    .buttonStyle(.borderedProminent)
                }
            }
        }
        .sheet(isPresented: $showingEncore) {
            EncoreWebView(
                apiKey: "pk_live_...",
                userId: currentUser.id,
                attributes: [
                    "subscriptionTier": "free",
                    "email": currentUser.email
                ],
                onEntitlementGranted: { entitlement in
                    handleEntitlementGranted(entitlement)
                }
            )
        }
        .alert("Success!", isPresented: $showSuccess) {
            Button("OK") {
                showSuccess = false
            }
        } message: {
            Text(successMessage)
        }
    }
    
    func handleEntitlementGranted(_ entitlement: EncoreEntitlement) {
        switch entitlement.type {
        case .freeTrial:
            let days = entitlement.value ?? 7
            enableFreeTrial(duration: days)
            successMessage = "You now have \(days) days of premium access!"
            
        case .discount:
            let percent = entitlement.value ?? 20
            applyDiscount(percent: percent)
            successMessage = "You've earned a \(percent)% discount on your next purchase!"
            
        case .credit:
            let amount = entitlement.value ?? 10
            addCredit(amount: amount)
            successMessage = "You've received $\(amount) in account credit!"
        }
        
        showSuccess = true
        showingEncore = false
    }
    
    func enableFreeTrial(duration: Int) {
        isPremium = true
        
        // Store locally
        UserDefaults.standard.set(true, forKey: "isPremium")
        UserDefaults.standard.set(Date().addingTimeInterval(Double(duration * 86400)), forKey: "premiumExpiry")
        
        // Sync with server (important!)
        Task {
            await syncPremiumStatusWithServer()
        }
    }
    
    func applyDiscount(percent: Int) {
        UserDefaults.standard.set(percent, forKey: "pendingDiscount")
    }
    
    func addCredit(amount: Int) {
        let currentCredit = UserDefaults.standard.integer(forKey: "accountCredit")
        UserDefaults.standard.set(currentCredit + amount, forKey: "accountCredit")
    }
    
    func syncPremiumStatusWithServer() async {
        // Validate with your backend
        // Your server calls Encore's entitlements API with HMAC authentication
    }
}

class EntitlementValidator {
    
    /// Call your backend to validate entitlements
    func validateEntitlements(userId: String) async throws -> EntitlementResponse {
        let url = URL(string: "https://your-backend.com/api/validate-entitlements")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try JSONEncoder().encode(["userId": userId])
        
        let (data, _) = try await URLSession.shared.data(for: request)
        return try JSONDecoder().decode(EntitlementResponse.self, from: data)
    }
    
    /// Check if user has a specific entitlement
    func hasEntitlement(userId: String, type: String, scope: String = "all") async -> Bool {
        do {
            let response = try await validateEntitlements(userId: userId)
            let scopeData: [String: EntitlementData]?
            
            switch scope {
            case "verified": scopeData = response.verified
            case "provisional": scopeData = response.provisional
            default: scopeData = response.all
            }
            
            return scopeData?[type] != nil
        } catch {
            print("Validation failed: \(error)")
            return false
        }
    }
}

struct EntitlementResponse: Codable {
    let all: [String: EntitlementData]?
    let verified: [String: EntitlementData]?
    let provisional: [String: EntitlementData]?
}

struct EntitlementData: Codable {
    let type: String
    let value: Int?
    let unit: String?
    let scope: String
    let grantedAt: String
    let expiresAt: String
    let transactionId: String?
}

import crypto from 'crypto';

function generateHmacSignature(privateKey, method, path, body) {
  const bodyJson = JSON.stringify(body);
  const canonical = `${method.toUpperCase()}|${path}|${bodyJson}`;
  const hmac = crypto.createHmac('sha256', privateKey);
  hmac.update(canonical);
  return hmac.digest('hex');
}

app.post('/api/validate-entitlements', async (req, res) => {
  const { userId } = req.body;
  
  const method = 'POST';
  const path = '/encore/v1/entitlements/server';
  const body = { user_id: userId };
  
  const signature = generateHmacSignature(
    process.env.ENCORE_PRIVATE_API_KEY,
    method,
    path,
    body
  );
  
  const timestamp = Math.floor(Date.now() / 1000);
  
  const response = await fetch(`${process.env.ENCORE_BASE_URL}${path}`, {
    method,
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': process.env.ENCORE_PUBLIC_API_KEY,
      'X-Signature': signature,
      'X-Timestamp': timestamp.toString(),
    },
    body: JSON.stringify(body),
  });
  
  const entitlements = await response.json();
  res.json(entitlements);
});