Love Always AI: Designing for Heart

//
//  AICompanionNetworkManager.swift
//  Portfolio sample — sanitized excerpt from a production AI companion app
//
//  This file demonstrates the async networking layer that powers a
//  conversational AI companion feature: sending chat context to a backend,
//  handling a "search-augmented" retry flow, and parsing the response.
//
//  NOTE: All API keys, endpoints, prompt text, and app-specific business
//  logic have been removed or replaced with placeholders. This is a
//  structural example of coding style, not the production implementation.
//

import Foundation
import Combine

@MainActor
class AICompanionNetworkManager: ObservableObject {
    static let shared = AICompanionNetworkManager()

    @Published var isLoading: Bool = false

    // MARK: - Backend Configuration
    // Real deployments should never hardcode secrets. Pull them from the
    // environment (CI/CD, xcconfig, or a secrets manager) instead.
    private let backendURL = ProcessInfo.processInfo.environment["AI_BACKEND_URL"]
        ?? "https://api.example.com/chat"
    private let appSecret = ProcessInfo.processInfo.environment["AI_APP_SECRET"] ?? ""

    private let iso8601: ISO8601DateFormatter = {
        let formatter = ISO8601DateFormatter()
        formatter.timeZone = .current
        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        return formatter
    }()

    // MARK: - Generate Response
    //
    // Sends the current user message plus a trimmed window of conversation
    // history and long-term "memories" to the backend. If the model asks for
    // a live web search mid-response, this performs the search and re-asks
    // with the results injected — a lightweight agentic retry loop.
    func generateResponse(
        for userText: String,
        conversationHistory: [ChatMessage],
        memories: [String],
        weather: String = ""
    ) async -> String {
        self.isLoading = true
        defer { self.isLoading = false }

        let searchResults: String
        if needsWebSearch(userText) {
            searchResults = await performWebSearch(query: userText)
        } else {
            searchResults = ""
        }

        // Only send a bounded window of recent turns to keep payloads small
        // and avoid leaking unbounded history into the prompt.
        let historyArray: [[String: String]] = conversationHistory
            .suffix(8)
            .map { ["role": $0.role, "content": $0.text] }

        do {
            let response = try await postBackendRequest(
                message: userText,
                history: historyArray,
                memories: Array(memories.prefix(10)),
                weather: weather,
                searchResults: searchResults
            )
            let trimmed = response.trimmingCharacters(in: .whitespacesAndNewlines)

            // If the model signals it needs a live search to answer well,
            // perform it and make one follow-up request with the results.
            if let searchQuery = extractSearchQuery(from: trimmed) {
                let manualResults = await performWebSearch(query: searchQuery)
                let finalResponse = try await postBackendRequest(
                    message: userText,
                    history: historyArray,
                    memories: Array(memories.prefix(10)),
                    weather: weather,
                    searchResults: String(manualResults.prefix(1000))
                )
                return finalResponse.trimmingCharacters(in: .whitespacesAndNewlines)
            }

            return trimmed
        } catch {
            print("❌ Backend error: \(error)")
            return "Something went wrong reaching the AI service. Please try again."
        }
    }

    // MARK: - Backend Request

    /// Posts the conversation payload to the backend and returns the raw
    /// text response. Throws on network failure, a non-2xx status code, or
    /// an unparseable response body.
    private func postBackendRequest(
        message: String,
        history: [[String: String]],
        memories: [String],
        weather: String,
        searchResults: String = ""
    ) async throws -> String {
        guard let url = URL(string: backendURL) else { throw URLError(.badURL) }

        var bodyDict: [String: Any] = [
            "message": message,
            "history": history,
            "memories": memories,
            "weather": weather,
            "clientTime": iso8601.string(from: Date()),
            "timezone": TimeZone.current.identifier
            // Insert any additional system prompt / persona configuration here.
        ]
        if !searchResults.isEmpty {
            bodyDict["searchResults"] = searchResults
        }

        let encoded = try JSONSerialization.data(withJSONObject: bodyDict)
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(appSecret, forHTTPHeaderField: "x-app-secret")
        request.httpBody = encoded
        request.timeoutInterval = 90

        let (data, response) = try await URLSession.shared.data(for: request)

        if let http = response as? HTTPURLResponse, !(200...299).contains(http.statusCode) {
            let preview = String(data: data.prefix(300), encoding: .utf8) ?? ""
            print("❌ Backend HTTP \(http.statusCode): \(preview)")
            throw URLError(.badServerResponse)
        }

        guard let parsed = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
              let content = parsed["response"] as? String else {
            throw URLError(.cannotParseResponse)
        }

        return content
    }

    // MARK: - Helpers

    /// Simple keyword heuristic to decide whether a user message likely
    /// needs fresh, real-world information the model wouldn't know on its own.
    private func needsWebSearch(_ text: String) -> Bool {
        let lower = text.lowercased()
        let searchKeywords = [
            "latest news", "new release", "just released", "news about",
            "price of", "how much is", "trending", "recently released"
        ]
        return searchKeywords.contains { lower.contains($0) }
    }

    /// Looks for a `SEARCH: <query>` directive the model can emit when it
    /// decides it needs live information to answer well.
    private func extractSearchQuery(from response: String) -> String? {
        let searchPattern = "SEARCH:\\s*([^\\n|]+)"
        guard let regex = try? NSRegularExpression(pattern: searchPattern, options: [.caseInsensitive]),
              let match = regex.firstMatch(in: response, range: NSRange(response.startIndex..., in: response)),
              let queryRange = Range(match.range(at: 1), in: response) else { return nil }
        let query = String(response[queryRange]).trimmingCharacters(in: .whitespacesAndNewlines)
        return query.isEmpty ? nil : query
    }

    /// Stub — swap in your actual search provider (e.g. a search API client).
    private func performWebSearch(query: String) async -> String {
        return ""
    }
}

struct ChatMessage {
    let role: String
    let text: String
}