SwiftUI_iOS_Reference_Complete.swift

// SWIFT IOS MOBILE DEVELOPMENT - Comprehensive Reference - by Richard Rembert
// Swift with SwiftUI enables building modern, declarative iOS applications with powerful
// frameworks like Combine, Core Data, and native iOS integrations

// ═══════════════════════════════════════════════════════════════════════════════
//                           1. SETUP AND PROJECT STRUCTURE
// ═══════════════════════════════════════════════════════════════════════════════

/*
SWIFT IOS DEVELOPMENT SETUP:

1. Xcode Installation:
   - Download from Mac App Store or Apple Developer Portal
   - Minimum Xcode 15.0+ for iOS 17+ development
   - Include iOS Simulator and Command Line Tools

2. Project Creation:
   - Choose "iOS App" template
   - Select "SwiftUI" for Interface
   - Choose "Swift" as Language
   - Select minimum deployment target (iOS 15+ recommended)

3. Essential Frameworks and Dependencies:
   - SwiftUI (UI Framework)
   - Combine (Reactive Programming)
   - Core Data (Local Database)
   - URLSession (Networking)
   - Foundation (Core Utilities)
   - UserNotifications (Push Notifications)
   - Security (Keychain Access)

4. Package Manager Dependencies (Package.swift or SPM):
   - Alamofire (Networking - alternative to URLSession)
   - Kingfisher (Image Loading and Caching)
   - SwiftGen (Code Generation for Resources)
   - Realm (Alternative Database)
   - Firebase SDK (Analytics, Auth, etc.)

5. Project Structure:
   MyApp/
   ├── App/
   │   ├── MyAppApp.swift
   │   ├── ContentView.swift
   │   └── Info.plist
   ├── Core/
   │   ├── Network/
   │   ├── Database/
   │   ├── Authentication/
   │   └── Utils/
   ├── Features/
   │   ├── Authentication/
   │   ├── Posts/
   │   ├── Profile/
   │   └── Settings/
   ├── Models/
   │   ├── Domain/
   │   ├── Network/
   │   └── CoreData/
   ├── Views/
   │   ├── Components/
   │   ├── Screens/
   │   └── Modifiers/
   ├── ViewModels/
   ├── Services/
   ├── Resources/
   │   ├── Assets.xcassets
   │   ├── Localizable.strings
   │   └── Colors.xcassets
   └── Tests/
       ├── UnitTests/
       ├── UITests/
       └── IntegrationTests/

6. Configuration Files:
   - Info.plist (App configuration)
   - Entitlements.plist (App capabilities)
   - Configuration.plist (Environment settings)
*/

import SwiftUI
import Combine
import Foundation

// ═══════════════════════════════════════════════════════════════════════════════
//                           2. APP ENTRY POINT AND CONFIGURATION
// ═══════════════════════════════════════════════════════════════════════════════

@main
struct MyAppApp: App {
    @StateObject private var appState = AppState()
    @StateObject private var authenticationService = AuthenticationService()
    @StateObject private var networkMonitor = NetworkMonitor()
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(appState)
                .environmentObject(authenticationService)
                .environmentObject(networkMonitor)
                .onAppear {
                    setupApp()
                }
                .onReceive(NotificationCenter.default.publisher(for: UIApplication.didEnterBackgroundNotification)) { _ in
                    handleAppDidEnterBackground()
                }
                .onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) { _ in
                    handleAppWillEnterForeground()
                }
        }
    }
    
    private func setupApp() {
        configureAppearance()
        setupAnalytics()
        requestNotificationPermissions()
    }
    
    private func configureAppearance() {
        // Configure global UI appearance
        let appearance = UINavigationBarAppearance()
        appearance.configureWithOpaqueBackground()
        appearance.backgroundColor = UIColor.systemBackground
        appearance.titleTextAttributes = [.foregroundColor: UIColor.label]
        
        UINavigationBar.appearance().standardAppearance = appearance
        UINavigationBar.appearance().scrollEdgeAppearance = appearance
    }
    
    private func setupAnalytics() {
        // Initialize analytics services
        AnalyticsManager.shared.initialize()
    }
    
    private func requestNotificationPermissions() {
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in
            DispatchQueue.main.async {
                appState.notificationsEnabled = granted
            }
        }
    }
    
    private func handleAppDidEnterBackground() {
        // Save app state, pause timers, etc.
        appState.saveState()
    }
    
    private func handleAppWillEnterForeground() {
        // Refresh data, resume timers, etc.
        appState.refreshData()
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           3. APP STATE MANAGEMENT
// ═══════════════════════════════════════════════════════════════════════════════

class AppState: ObservableObject {
    @Published var isLoading = false
    @Published var errorMessage: String?
    @Published var notificationsEnabled = false
    @Published var selectedTab: Tab = .posts
    @Published var deepLinkURL: URL?
    
    enum Tab: String, CaseIterable {
        case posts = "Posts"
        case explore = "Explore"
        case favorites = "Favorites"
        case profile = "Profile"
        
        var iconName: String {
            switch self {
            case .posts: return "doc.text"
            case .explore: return "magnifyingglass"
            case .favorites: return "heart"
            case .profile: return "person"
            }
        }
    }
    
    func showError(_ message: String) {
        errorMessage = message
    }
    
    func clearError() {
        errorMessage = nil
    }
    
    func saveState() {
        UserDefaults.standard.set(selectedTab.rawValue, forKey: "selectedTab")
    }
    
    func loadState() {
        if let tabString = UserDefaults.standard.string(forKey: "selectedTab"),
           let tab = Tab(rawValue: tabString) {
            selectedTab = tab
        }
    }
    
    func refreshData() {
        // Trigger data refresh across the app
        NotificationCenter.default.post(name: .refreshData, object: nil)
    }
}

extension Notification.Name {
    static let refreshData = Notification.Name("refreshData")
    static let userDidLogin = Notification.Name("userDidLogin")
    static let userDidLogout = Notification.Name("userDidLogout")
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           4. MODELS AND DATA STRUCTURES
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - Domain Models

struct User: Identifiable, Codable, Equatable {
    let id: String
    let email: String
    let username: String
    let firstName: String
    let lastName: String
    let avatarURL: URL?
    let bio: String?
    let isActive: Bool
    let createdAt: Date
    let updatedAt: Date
    
    var fullName: String {
        "\(firstName) \(lastName)"
    }
    
    var initials: String {
        let first = firstName.prefix(1).uppercased()
        let last = lastName.prefix(1).uppercased()
        return "\(first)\(last)"
    }
}

struct Post: Identifiable, Codable, Equatable {
    let id: String
    let title: String
    let content: String
    let excerpt: String
    let imageURL: URL?
    let authorID: String
    let author: User?
    let categoryID: String
    let category: Category?
    let tags: [String]
    let isPublished: Bool
    let viewCount: Int
    let likeCount: Int
    let commentCount: Int
    let isLiked: Bool
    let publishedAt: Date?
    let createdAt: Date
    let updatedAt: Date
    
    var readingTimeMinutes: Int {
        let wordsPerMinute = 200
        let wordCount = content.components(separatedBy: .whitespacesAndNewlines).count
        return max(1, wordCount / wordsPerMinute)
    }
    
    var isPublic: Bool {
        isPublished && publishedAt != nil
    }
    
    var formattedPublishDate: String {
        guard let publishedAt = publishedAt else { return "" }
        return DateFormatter.mediumDate.string(from: publishedAt)
    }
}

struct Category: Identifiable, Codable, Equatable {
    let id: String
    let name: String
    let slug: String
    let description: String
    let color: String
    let postCount: Int
    
    var colorValue: Color {
        Color(hex: color) ?? .blue
    }
}

struct Comment: Identifiable, Codable, Equatable {
    let id: String
    let content: String
    let postID: String
    let authorID: String
    let author: User?
    let parentID: String?
    let replies: [Comment]
    let createdAt: Date
    let updatedAt: Date
    
    var isReply: Bool {
        parentID != nil
    }
    
    var timeAgo: String {
        createdAt.timeAgoDisplay()
    }
}

// MARK: - Network DTOs

struct UserDTO: Codable {
    let id: String
    let email: String
    let username: String
    let firstName: String
    let lastName: String
    let avatarURL: String?
    let bio: String?
    let isActive: Bool
    let createdAt: String
    let updatedAt: String
    
    private enum CodingKeys: String, CodingKey {
        case id, email, username, bio
        case firstName = "first_name"
        case lastName = "last_name"
        case avatarURL = "avatar_url"
        case isActive = "is_active"
        case createdAt = "created_at"
        case updatedAt = "updated_at"
    }
}

struct PostDTO: Codable {
    let id: String
    let title: String
    let content: String
    let excerpt: String
    let imageURL: String?
    let authorID: String
    let author: UserDTO?
    let categoryID: String
    let category: CategoryDTO?
    let tags: [String]
    let isPublished: Bool
    let viewCount: Int
    let likeCount: Int
    let commentCount: Int
    let isLiked: Bool
    let publishedAt: String?
    let createdAt: String
    let updatedAt: String
    
    private enum CodingKeys: String, CodingKey {
        case id, title, content, excerpt, tags
        case imageURL = "image_url"
        case authorID = "author_id"
        case author, category
        case categoryID = "category_id"
        case isPublished = "is_published"
        case viewCount = "view_count"
        case likeCount = "like_count"
        case commentCount = "comment_count"
        case isLiked = "is_liked"
        case publishedAt = "published_at"
        case createdAt = "created_at"
        case updatedAt = "updated_at"
    }
}

struct CategoryDTO: Codable {
    let id: String
    let name: String
    let slug: String
    let description: String
    let color: String
    let postCount: Int
    
    private enum CodingKeys: String, CodingKey {
        case id, name, slug, description, color
        case postCount = "post_count"
    }
}

// MARK: - API Response Models

struct APIResponse<T: Codable>: Codable {
    let success: Bool
    let data: T?
    let message: String?
    let errors: [String]?
}

struct PaginatedResponse<T: Codable>: Codable {
    let success: Bool
    let data: [T]
    let pagination: PaginationInfo
    let message: String?
    let errors: [String]?
}

struct PaginationInfo: Codable {
    let currentPage: Int
    let totalPages: Int
    let totalItems: Int
    let itemsPerPage: Int
    let hasNext: Bool
    let hasPrevious: Bool
    
    private enum CodingKeys: String, CodingKey {
        case currentPage = "current_page"
        case totalPages = "total_pages"
        case totalItems = "total_items"
        case itemsPerPage = "items_per_page"
        case hasNext = "has_next"
        case hasPrevious = "has_previous"
    }
}

// MARK: - Authentication Models

struct LoginRequest: Codable {
    let email: String
    let password: String
}

struct RegisterRequest: Codable {
    let email: String
    let username: String
    let firstName: String
    let lastName: String
    let password: String
    
    private enum CodingKeys: String, CodingKey {
        case email, username, password
        case firstName = "first_name"
        case lastName = "last_name"
    }
}

struct AuthResponse: Codable {
    let accessToken: String
    let refreshToken: String
    let expiresIn: Int
    let user: UserDTO
    
    private enum CodingKeys: String, CodingKey {
        case accessToken = "access_token"
        case refreshToken = "refresh_token"
        case expiresIn = "expires_in"
        case user
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           5. DATA MAPPERS
// ═══════════════════════════════════════════════════════════════════════════════

enum DataMapper {
    
    // MARK: - User Mapping
    
    static func mapUser(from dto: UserDTO) -> User {
        User(
            id: dto.id,
            email: dto.email,
            username: dto.username,
            firstName: dto.firstName,
            lastName: dto.lastName,
            avatarURL: dto.avatarURL.flatMap(URL.init),
            bio: dto.bio,
            isActive: dto.isActive,
            createdAt: DateFormatter.iso8601.date(from: dto.createdAt) ?? Date(),
            updatedAt: DateFormatter.iso8601.date(from: dto.updatedAt) ?? Date()
        )
    }
    
    // MARK: - Post Mapping
    
    static func mapPost(from dto: PostDTO) -> Post {
        Post(
            id: dto.id,
            title: dto.title,
            content: dto.content,
            excerpt: dto.excerpt,
            imageURL: dto.imageURL.flatMap(URL.init),
            authorID: dto.authorID,
            author: dto.author.map(mapUser),
            categoryID: dto.categoryID,
            category: dto.category.map(mapCategory),
            tags: dto.tags,
            isPublished: dto.isPublished,
            viewCount: dto.viewCount,
            likeCount: dto.likeCount,
            commentCount: dto.commentCount,
            isLiked: dto.isLiked,
            publishedAt: dto.publishedAt.flatMap { DateFormatter.iso8601.date(from: $0) },
            createdAt: DateFormatter.iso8601.date(from: dto.createdAt) ?? Date(),
            updatedAt: DateFormatter.iso8601.date(from: dto.updatedAt) ?? Date()
        )
    }
    
    // MARK: - Category Mapping
    
    static func mapCategory(from dto: CategoryDTO) -> Category {
        Category(
            id: dto.id,
            name: dto.name,
            slug: dto.slug,
            description: dto.description,
            color: dto.color,
            postCount: dto.postCount
        )
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           6. NETWORKING LAYER
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - Network Manager

class NetworkManager: ObservableObject {
    static let shared = NetworkManager()
    
    private let baseURL = "https://api.example.com/v1"
    private var cancellables = Set<AnyCancellable>()
    
    private lazy var session: URLSession = {
        let config = URLSessionConfiguration.default
        config.timeoutIntervalForRequest = 30
        config.timeoutIntervalForResource = 60
        config.waitsForConnectivity = true
        return URLSession(configuration: config)
    }()
    
    private init() {}
    
    // MARK: - Generic Request Method
    
    func request<T: Codable>(
        endpoint: APIEndpoint,
        responseType: T.Type,
        completion: @escaping (Result<T, NetworkError>) -> Void
    ) {
        guard let url = endpoint.url(baseURL: baseURL) else {
            completion(.failure(.invalidURL))
            return
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = endpoint.method.rawValue
        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
        
        // Add authentication token if available
        if let token = KeychainManager.shared.getAccessToken() {
            request.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
        }
        
        // Add request body for POST/PUT requests
        if let body = endpoint.body {
            do {
                request.httpBody = try JSONSerialization.data(withJSONObject: body)
            } catch {
                completion(.failure(.encodingError))
                return
            }
        }
        
        session.dataTask(with: request) { data, response, error in
            DispatchQueue.main.async {
                if let error = error {
                    completion(.failure(.networkError(error.localizedDescription)))
                    return
                }
                
                guard let httpResponse = response as? HTTPURLResponse else {
                    completion(.failure(.invalidResponse))
                    return
                }
                
                guard 200...299 ~= httpResponse.statusCode else {
                    let errorMessage = self.parseErrorMessage(from: data)
                    completion(.failure(.serverError(httpResponse.statusCode, errorMessage)))
                    return
                }
                
                guard let data = data else {
                    completion(.failure(.noData))
                    return
                }
                
                do {
                    let decodedResponse = try JSONDecoder().decode(T.self, from: data)
                    completion(.success(decodedResponse))
                } catch {
                    print("Decoding error: \(error)")
                    completion(.failure(.decodingError))
                }
            }
        }.resume()
    }
    
    // MARK: - Combine-based Request Method
    
    func requestPublisher<T: Codable>(
        endpoint: APIEndpoint,
        responseType: T.Type
    ) -> AnyPublisher<T, NetworkError> {
        guard let url = endpoint.url(baseURL: baseURL) else {
            return Fail(error: NetworkError.invalidURL)
                .eraseToAnyPublisher()
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = endpoint.method.rawValue
        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
        
        if let token = KeychainManager.shared.getAccessToken() {
            request.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
        }
        
        if let body = endpoint.body {
            do {
                request.httpBody = try JSONSerialization.data(withJSONObject: body)
            } catch {
                return Fail(error: NetworkError.encodingError)
                    .eraseToAnyPublisher()
            }
        }
        
        return session.dataTaskPublisher(for: request)
            .map(\.data)
            .decode(type: T.self, decoder: JSONDecoder())
            .mapError { error in
                if error is DecodingError {
                    return NetworkError.decodingError
                } else {
                    return NetworkError.networkError(error.localizedDescription)
                }
            }
            .eraseToAnyPublisher()
    }
    
    private func parseErrorMessage(from data: Data?) -> String {
        guard let data = data else { return "Unknown error" }
        
        do {
            if let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
               let message = json["message"] as? String {
                return message
            }
        } catch {}
        
        return "Server error"
    }
}

// MARK: - API Endpoints

enum APIEndpoint {
    // Authentication
    case login(email: String, password: String)
    case register(RegisterRequest)
    case refreshToken(String)
    case logout
    
    // Posts
    case getPosts(page: Int, limit: Int, categoryID: String?, search: String?)
    case getPost(id: String)
    case createPost(CreatePostRequest)
    case updatePost(id: String, UpdatePostRequest)
    case deletePost(id: String)
    case likePost(id: String)
    case unlikePost(id: String)
    
    // Users
    case getUser(id: String)
    case updateUser(id: String, UpdateUserRequest)
    case getCurrentUser
    
    // Categories
    case getCategories
    case getCategory(id: String)
    
    var path: String {
        switch self {
        case .login: return "/auth/login"
        case .register: return "/auth/register"
        case .refreshToken: return "/auth/refresh"
        case .logout: return "/auth/logout"
        case .getPosts: return "/posts"
        case .getPost(let id): return "/posts/\(id)"
        case .createPost: return "/posts"
        case .updatePost(let id, _): return "/posts/\(id)"
        case .deletePost(let id): return "/posts/\(id)"
        case .likePost(let id): return "/posts/\(id)/like"
        case .unlikePost(let id): return "/posts/\(id)/like"
        case .getUser(let id): return "/users/\(id)"
        case .updateUser(let id, _): return "/users/\(id)"
        case .getCurrentUser: return "/users/me"
        case .getCategories: return "/categories"
        case .getCategory(let id): return "/categories/\(id)"
        }
    }
    
    var method: HTTPMethod {
        switch self {
        case .login, .register, .refreshToken, .createPost, .likePost:
            return .POST
        case .updatePost, .updateUser:
            return .PUT
        case .deletePost, .logout, .unlikePost:
            return .DELETE
        default:
            return .GET
        }
    }
    
    var queryItems: [URLQueryItem]? {
        switch self {
        case .getPosts(let page, let limit, let categoryID, let search):
            var items = [
                URLQueryItem(name: "page", value: "\(page)"),
                URLQueryItem(name: "limit", value: "\(limit)")
            ]
            if let categoryID = categoryID {
                items.append(URLQueryItem(name: "category", value: categoryID))
            }
            if let search = search {
                items.append(URLQueryItem(name: "search", value: search))
            }
            return items
        default:
            return nil
        }
    }
    
    var body: [String: Any]? {
        switch self {
        case .login(let email, let password):
            return ["email": email, "password": password]
        case .register(let request):
            return try? request.asDictionary()
        case .refreshToken(let token):
            return ["refresh_token": token]
        case .createPost(let request):
            return try? request.asDictionary()
        case .updatePost(_, let request):
            return try? request.asDictionary()
        case .updateUser(_, let request):
            return try? request.asDictionary()
        default:
            return nil
        }
    }
    
    func url(baseURL: String) -> URL? {
        var components = URLComponents(string: baseURL + path)
        components?.queryItems = queryItems
        return components?.url
    }
}

enum HTTPMethod: String {
    case GET = "GET"
    case POST = "POST"
    case PUT = "PUT"
    case DELETE = "DELETE"
}

// MARK: - Network Error

enum NetworkError: Error, LocalizedError {
    case invalidURL
    case noData
    case decodingError
    case encodingError
    case networkError(String)
    case serverError(Int, String)
    case invalidResponse
    case unauthorized
    
    var errorDescription: String? {
        switch self {
        case .invalidURL:
            return "Invalid URL"
        case .noData:
            return "No data received"
        case .decodingError:
            return "Failed to decode response"
        case .encodingError:
            return "Failed to encode request"
        case .networkError(let message):
            return "Network error: \(message)"
        case .serverError(let code, let message):
            return "Server error \(code): \(message)"
        case .invalidResponse:
            return "Invalid response"
        case .unauthorized:
            return "Unauthorized access"
        }
    }
}

// MARK: - Request Models

struct CreatePostRequest: Codable {
    let title: String
    let content: String
    let excerpt: String?
    let categoryID: String
    let tags: [String]
    let isPublished: Bool
    
    private enum CodingKeys: String, CodingKey {
        case title, content, excerpt, tags
        case categoryID = "category_id"
        case isPublished = "is_published"
    }
}

struct UpdatePostRequest: Codable {
    let title: String?
    let content: String?
    let excerpt: String?
    let categoryID: String?
    let tags: [String]?
    let isPublished: Bool?
    
    private enum CodingKeys: String, CodingKey {
        case title, content, excerpt, tags
        case categoryID = "category_id"
        case isPublished = "is_published"
    }
}

struct UpdateUserRequest: Codable {
    let firstName: String?
    let lastName: String?
    let username: String?
    let bio: String?
    
    private enum CodingKeys: String, CodingKey {
        case username, bio
        case firstName = "first_name"
        case lastName = "last_name"
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           7. CORE DATA INTEGRATION
// ═══════════════════════════════════════════════════════════════════════════════

import CoreData

// MARK: - Core Data Stack

class CoreDataManager: ObservableObject {
    static let shared = CoreDataManager()
    
    private init() {}
    
    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "DataModel")
        container.loadPersistentStores { _, error in
            if let error = error {
                fatalError("Core Data error: \(error.localizedDescription)")
            }
        }
        container.viewContext.automaticallyMergesChangesFromParent = true
        return container
    }()
    
    var viewContext: NSManagedObjectContext {
        persistentContainer.viewContext
    }
    
    func save() {
        let context = viewContext
        
        if context.hasChanges {
            do {
                try context.save()
            } catch {
                print("Save error: \(error)")
            }
        }
    }
    
    func delete(_ object: NSManagedObject) {
        viewContext.delete(object)
        save()
    }
    
    // MARK: - User Operations
    
    func saveUser(_ user: User) {
        let userEntity = UserEntity(context: viewContext)
        userEntity.id = user.id
        userEntity.email = user.email
        userEntity.username = user.username
        userEntity.firstName = user.firstName
        userEntity.lastName = user.lastName
        userEntity.avatarURL = user.avatarURL?.absoluteString
        userEntity.bio = user.bio
        userEntity.isActive = user.isActive
        userEntity.createdAt = user.createdAt
        userEntity.updatedAt = user.updatedAt
        
        save()
    }
    
    func fetchUser(withID id: String) -> User? {
        let request: NSFetchRequest<UserEntity> = UserEntity.fetchRequest()
        request.predicate = NSPredicate(format: "id == %@", id)
        request.fetchLimit = 1
        
        do {
            let userEntities = try viewContext.fetch(request)
            return userEntities.first?.toDomainModel()
        } catch {
            print("Fetch user error: \(error)")
            return nil
        }
    }
    
    // MARK: - Post Operations
    
    func savePosts(_ posts: [Post]) {
        posts.forEach { post in
            let postEntity = PostEntity(context: viewContext)
            postEntity.id = post.id
            postEntity.title = post.title
            postEntity.content = post.content
            postEntity.excerpt = post.excerpt
            postEntity.imageURL = post.imageURL?.absoluteString
            postEntity.authorID = post.authorID
            postEntity.categoryID = post.categoryID
            postEntity.tags = post.tags.joined(separator: ",")
            postEntity.isPublished = post.isPublished
            postEntity.viewCount = Int32(post.viewCount)
            postEntity.likeCount = Int32(post.likeCount)
            postEntity.commentCount = Int32(post.commentCount)
            postEntity.isLiked = post.isLiked
            postEntity.publishedAt = post.publishedAt
            postEntity.createdAt = post.createdAt
            postEntity.updatedAt = post.updatedAt
        }
        
        save()
    }
    
    func fetchPosts() -> [Post] {
        let request: NSFetchRequest<PostEntity> = PostEntity.fetchRequest()
        request.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
        
        do {
            let postEntities = try viewContext.fetch(request)
            return postEntities.compactMap { $0.toDomainModel() }
        } catch {
            print("Fetch posts error: \(error)")
            return []
        }
    }
    
    func searchPosts(query: String) -> [Post] {
        let request: NSFetchRequest<PostEntity> = PostEntity.fetchRequest()
        request.predicate = NSPredicate(format: "title CONTAINS[cd] %@ OR content CONTAINS[cd] %@", query, query)
        request.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
        
        do {
            let postEntities = try viewContext.fetch(request)
            return postEntities.compactMap { $0.toDomainModel() }
        } catch {
            print("Search posts error: \(error)")
            return []
        }
    }
    
    func clearAllData() {
        let entities = ["UserEntity", "PostEntity", "CategoryEntity"]
        
        entities.forEach { entityName in
            let request = NSFetchRequest<NSFetchRequestResult>(entityName: entityName)
            let deleteRequest = NSBatchDeleteRequest(fetchRequest: request)
            
            do {
                try viewContext.execute(deleteRequest)
            } catch {
                print("Clear data error for \(entityName): \(error)")
            }
        }
        
        save()
    }
}

// MARK: - Core Data Extensions

extension UserEntity {
    func toDomainModel() -> User? {
        guard let id = id,
              let email = email,
              let username = username,
              let firstName = firstName,
              let lastName = lastName,
              let createdAt = createdAt,
              let updatedAt = updatedAt else {
            return nil
        }
        
        return User(
            id: id,
            email: email,
            username: username,
            firstName: firstName,
            lastName: lastName,
            avatarURL: avatarURL.flatMap(URL.init),
            bio: bio,
            isActive: isActive,
            createdAt: createdAt,
            updatedAt: updatedAt
        )
    }
}

extension PostEntity {
    func toDomainModel() -> Post? {
        guard let id = id,
              let title = title,
              let content = content,
              let excerpt = excerpt,
              let authorID = authorID,
              let categoryID = categoryID,
              let createdAt = createdAt,
              let updatedAt = updatedAt else {
            return nil
        }
        
        let tagsArray = tags?.components(separatedBy: ",").filter { !$0.isEmpty } ?? []
        
        return Post(
            id: id,
            title: title,
            content: content,
            excerpt: excerpt,
            imageURL: imageURL.flatMap(URL.init),
            authorID: authorID,
            author: nil, // Would need to fetch separately
            categoryID: categoryID,
            category: nil, // Would need to fetch separately
            tags: tagsArray,
            isPublished: isPublished,
            viewCount: Int(viewCount),
            likeCount: Int(likeCount),
            commentCount: Int(commentCount),
            isLiked: isLiked,
            publishedAt: publishedAt,
            createdAt: createdAt,
            updatedAt: updatedAt
        )
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           8. AUTHENTICATION SERVICE
// ═══════════════════════════════════════════════════════════════════════════════

class AuthenticationService: ObservableObject {
    @Published var isAuthenticated = false
    @Published var currentUser: User?
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    private var cancellables = Set<AnyCancellable>()
    private let networkManager = NetworkManager.shared
    private let keychainManager = KeychainManager.shared
    
    init() {
        checkAuthenticationStatus()
    }
    
    // MARK: - Authentication Methods
    
    func login(email: String, password: String) {
        isLoading = true
        errorMessage = nil
        
        networkManager.requestPublisher(
            endpoint: .login(email: email, password: password),
            responseType: APIResponse<AuthResponse>.self
        )
        .receive(on: DispatchQueue.main)
        .sink(
            receiveCompletion: { [weak self] completion in
                self?.isLoading = false
                if case .failure(let error) = completion {
                    self?.errorMessage = error.localizedDescription
                }
            },
            receiveValue: { [weak self] response in
                if response.success, let authData = response.data {
                    self?.handleSuccessfulAuthentication(authData)
                } else {
                    self?.errorMessage = response.message ?? "Login failed"
                }
            }
        )
        .store(in: &cancellables)
    }
    
    func register(email: String, username: String, firstName: String, lastName: String, password: String) {
        isLoading = true
        errorMessage = nil
        
        let request = RegisterRequest(
            email: email,
            username: username,
            firstName: firstName,
            lastName: lastName,
            password: password
        )
        
        networkManager.requestPublisher(
            endpoint: .register(request),
            responseType: APIResponse<AuthResponse>.self
        )
        .receive(on: DispatchQueue.main)
        .sink(
            receiveCompletion: { [weak self] completion in
                self?.isLoading = false
                if case .failure(let error) = completion {
                    self?.errorMessage = error.localizedDescription
                }
            },
            receiveValue: { [weak self] response in
                if response.success, let authData = response.data {
                    self?.handleSuccessfulAuthentication(authData)
                } else {
                    self?.errorMessage = response.message ?? "Registration failed"
                }
            }
        )
        .store(in: &cancellables)
    }
    
    func logout() {
        networkManager.requestPublisher(
            endpoint: .logout,
            responseType: APIResponse<String>.self
        )
        .receive(on: DispatchQueue.main)
        .sink(
            receiveCompletion: { _ in },
            receiveValue: { [weak self] _ in
                self?.handleLogout()
            }
        )
        .store(in: &cancellables)
    }
    
    func refreshToken() {
        guard let refreshToken = keychainManager.getRefreshToken() else {
            handleLogout()
            return
        }
        
        networkManager.requestPublisher(
            endpoint: .refreshToken(refreshToken),
            responseType: APIResponse<AuthResponse>.self
        )
        .receive(on: DispatchQueue.main)
        .sink(
            receiveCompletion: { [weak self] completion in
                if case .failure = completion {
                    self?.handleLogout()
                }
            },
            receiveValue: { [weak self] response in
                if response.success, let authData = response.data {
                    self?.handleSuccessfulAuthentication(authData)
                } else {
                    self?.handleLogout()
                }
            }
        )
        .store(in: &cancellables)
    }
    
    // MARK: - Helper Methods
    
    private func handleSuccessfulAuthentication(_ authResponse: AuthResponse) {
        // Save tokens
        keychainManager.saveAccessToken(authResponse.accessToken)
        keychainManager.saveRefreshToken(authResponse.refreshToken)
        
        // Map and save user
        let user = DataMapper.mapUser(from: authResponse.user)
        currentUser = user
        CoreDataManager.shared.saveUser(user)
        
        // Update authentication state
        isAuthenticated = true
        
        // Post notification
        NotificationCenter.default.post(name: .userDidLogin, object: user)
    }
    
    private func handleLogout() {
        // Clear tokens
        keychainManager.clearTokens()
        
        // Clear user data
        currentUser = nil
        isAuthenticated = false
        
        // Clear Core Data
        CoreDataManager.shared.clearAllData()
        
        // Post notification
        NotificationCenter.default.post(name: .userDidLogout, object: nil)
    }
    
    private func checkAuthenticationStatus() {
        if keychainManager.getAccessToken() != nil {
            // Try to get current user
            getCurrentUser()
        }
    }
    
    private func getCurrentUser() {
        networkManager.requestPublisher(
            endpoint: .getCurrentUser,
            responseType: APIResponse<UserDTO>.self
        )
        .receive(on: DispatchQueue.main)
        .sink(
            receiveCompletion: { [weak self] completion in
                if case .failure = completion {
                    self?.handleLogout()
                }
            },
            receiveValue: { [weak self] response in
                if response.success, let userDTO = response.data {
                    let user = DataMapper.mapUser(from: userDTO)
                    self?.currentUser = user
                    self?.isAuthenticated = true
                    CoreDataManager.shared.saveUser(user)
                } else {
                    self?.handleLogout()
                }
            }
        )
        .store(in: &cancellables)
    }
    
    func clearError() {
        errorMessage = nil
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           9. KEYCHAIN MANAGER
// ═══════════════════════════════════════════════════════════════════════════════

import Security

class KeychainManager {
    static let shared = KeychainManager()
    
    private let service = Bundle.main.bundleIdentifier ?? "com.example.myapp"
    
    private enum Keys {
        static let accessToken = "access_token"
        static let refreshToken = "refresh_token"
    }
    
    private init() {}
    
    // MARK: - Token Management
    
    func saveAccessToken(_ token: String) {
        save(key: Keys.accessToken, value: token)
    }
    
    func getAccessToken() -> String? {
        return get(key: Keys.accessToken)
    }
    
    func saveRefreshToken(_ token: String) {
        save(key: Keys.refreshToken, value: token)
    }
    
    func getRefreshToken() -> String? {
        return get(key: Keys.refreshToken)
    }
    
    func clearTokens() {
        delete(key: Keys.accessToken)
        delete(key: Keys.refreshToken)
    }
    
    // MARK: - Generic Keychain Operations
    
    private func save(key: String, value: String) {
        guard let data = value.data(using: .utf8) else { return }
        
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: key,
            kSecValueData as String: data
        ]
        
        // Delete any existing item
        SecItemDelete(query as CFDictionary)
        
        // Add new item
        let status = SecItemAdd(query as CFDictionary, nil)
        if status != errSecSuccess {
            print("Keychain save error: \(status)")
        }
    }
    
    private func get(key: String) -> String? {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: key,
            kSecReturnData as String: true,
            kSecMatchLimit as String: kSecMatchLimitOne
        ]
        
        var result: AnyObject?
        let status = SecItemCopyMatching(query as CFDictionary, &result)
        
        if status == errSecSuccess,
           let data = result as? Data,
           let string = String(data: data, encoding: .utf8) {
            return string
        }
        
        return nil
    }
    
    private func delete(key: String) {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: key
        ]
        
        SecItemDelete(query as CFDictionary)
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           10. VIEW MODELS
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - Posts View Model

class PostsViewModel: ObservableObject {
    @Published var posts: [Post] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    @Published var searchText = ""
    @Published var selectedCategory: Category?
    @Published var currentPage = 1
    @Published var hasMorePages = true
    
    private var cancellables = Set<AnyCancellable>()
    private let networkManager = NetworkManager.shared
    private let itemsPerPage = 20
    
    init() {
        loadPosts()
        setupSearchDebounce()
    }
    
    // MARK: - Public Methods
    
    func loadPosts(refresh: Bool = false) {
        if refresh {
            currentPage = 1
            posts = []
            hasMorePages = true
        }
        
        guard hasMorePages && !isLoading else { return }
        
        isLoading = true
        errorMessage = nil
        
        networkManager.requestPublisher(
            endpoint: .getPosts(
                page: currentPage,
                limit: itemsPerPage,
                categoryID: selectedCategory?.id,
                search: searchText.isEmpty ? nil : searchText
            ),
            responseType: PaginatedResponse<PostDTO>.self
        )
        .receive(on: DispatchQueue.main)
        .sink(
            receiveCompletion: { [weak self] completion in
                self?.isLoading = false
                if case .failure(let error) = completion {
                    self?.errorMessage = error.localizedDescription
                }
            },
            receiveValue: { [weak self] response in
                guard let self = self else { return }
                
                if response.success {
                    let newPosts = response.data.map(DataMapper.mapPost)
                    
                    if refresh {
                        self.posts = newPosts
                    } else {
                        self.posts.append(contentsOf: newPosts)
                    }
                    
                    self.hasMorePages = response.pagination.hasNext
                    self.currentPage += 1
                    
                    // Cache posts locally
                    CoreDataManager.shared.savePosts(newPosts)
                } else {
                    self.errorMessage = response.message ?? "Failed to load posts"
                }
            }
        )
        .store(in: &cancellables)
    }
    
    func loadMorePosts() {
        loadPosts()
    }
    
    func refreshPosts() {
        loadPosts(refresh: true)
    }
    
    func searchPosts() {
        loadPosts(refresh: true)
    }
    
    func likePost(_ post: Post) {
        let endpoint: APIEndpoint = post.isLiked ? .unlikePost(id: post.id) : .likePost(id: post.id)
        
        networkManager.requestPublisher(
            endpoint: endpoint,
            responseType: APIResponse<String>.self
        )
        .receive(on: DispatchQueue.main)
        .sink(
            receiveCompletion: { [weak self] completion in
                if case .failure(let error) = completion {
                    self?.errorMessage = error.localizedDescription
                }
            },
            receiveValue: { [weak self] response in
                if response.success {
                    // Update local state
                    self?.updatePostLikeStatus(post)
                }
            }
        )
        .store(in: &cancellables)
    }
    
    func setCategory(_ category: Category?) {
        selectedCategory = category
        refreshPosts()
    }
    
    func clearError() {
        errorMessage = nil
    }
    
    // MARK: - Private Methods
    
    private func setupSearchDebounce() {
        $searchText
            .debounce(for: .milliseconds(500), scheduler: DispatchQueue.main)
            .removeDuplicates()
            .sink { [weak self] _ in
                self?.searchPosts()
            }
            .store(in: &cancellables)
    }
    
    private func updatePostLikeStatus(_ post: Post) {
        if let index = posts.firstIndex(where: { $0.id == post.id }) {
            posts[index] = Post(
                id: post.id,
                title: post.title,
                content: post.content,
                excerpt: post.excerpt,
                imageURL: post.imageURL,
                authorID: post.authorID,
                author: post.author,
                categoryID: post.categoryID,
                category: post.category,
                tags: post.tags,
                isPublished: post.isPublished,
                viewCount: post.viewCount,
                likeCount: post.isLiked ? post.likeCount - 1 : post.likeCount + 1,
                commentCount: post.commentCount,
                isLiked: !post.isLiked,
                publishedAt: post.publishedAt,
                createdAt: post.createdAt,
                updatedAt: post.updatedAt
            )
        }
    }
}

// MARK: - Post Detail View Model

class PostDetailViewModel: ObservableObject {
    @Published var post: Post?
    @Published var isLoading = false
    @Published var errorMessage: String?
    @Published var comments: [Comment] = []
    @Published var isLoadingComments = false
    
    private var cancellables = Set<AnyCancellable>()
    private let networkManager = NetworkManager.shared
    private let postID: String
    
    init(postID: String) {
        self.postID = postID
        loadPost()
        loadComments()
    }
    
    func loadPost() {
        isLoading = true
        errorMessage = nil
        
        networkManager.requestPublisher(
            endpoint: .getPost(id: postID),
            responseType: APIResponse<PostDTO>.self
        )
        .receive(on: DispatchQueue.main)
        .sink(
            receiveCompletion: { [weak self] completion in
                self?.isLoading = false
                if case .failure(let error) = completion {
                    self?.errorMessage = error.localizedDescription
                }
            },
            receiveValue: { [weak self] response in
                if response.success, let postDTO = response.data {
                    self?.post = DataMapper.mapPost(from: postDTO)
                } else {
                    self?.errorMessage = response.message ?? "Failed to load post"
                }
            }
        )
        .store(in: &cancellables)
    }
    
    func loadComments() {
        // Implementation for loading comments
        isLoadingComments = true
        // ... similar pattern as above
    }
    
    func likePost() {
        guard let post = post else { return }
        
        let endpoint: APIEndpoint = post.isLiked ? .unlikePost(id: post.id) : .likePost(id: post.id)
        
        networkManager.requestPublisher(
            endpoint: endpoint,
            responseType: APIResponse<String>.self
        )
        .receive(on: DispatchQueue.main)
        .sink(
            receiveCompletion: { [weak self] completion in
                if case .failure(let error) = completion {
                    self?.errorMessage = error.localizedDescription
                }
            },
            receiveValue: { [weak self] response in
                if response.success {
                    self?.updateLikeStatus()
                }
            }
        )
        .store(in: &cancellables)
    }
    
    private func updateLikeStatus() {
        guard let currentPost = post else { return }
        
        post = Post(
            id: currentPost.id,
            title: currentPost.title,
            content: currentPost.content,
            excerpt: currentPost.excerpt,
            imageURL: currentPost.imageURL,
            authorID: currentPost.authorID,
            author: currentPost.author,
            categoryID: currentPost.categoryID,
            category: currentPost.category,
            tags: currentPost.tags,
            isPublished: currentPost.isPublished,
            viewCount: currentPost.viewCount,
            likeCount: currentPost.isLiked ? currentPost.likeCount - 1 : currentPost.likeCount + 1,
            commentCount: currentPost.commentCount,
            isLiked: !currentPost.isLiked,
            publishedAt: currentPost.publishedAt,
            createdAt: currentPost.createdAt,
            updatedAt: currentPost.updatedAt
        )
    }
}

// MARK: - Categories View Model

class CategoriesViewModel: ObservableObject {
    @Published var categories: [Category] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    private var cancellables = Set<AnyCancellable>()
    private let networkManager = NetworkManager.shared
    
    init() {
        loadCategories()
    }
    
    func loadCategories() {
        isLoading = true
        errorMessage = nil
        
        networkManager.requestPublisher(
            endpoint: .getCategories,
            responseType: APIResponse<[CategoryDTO]>.self
        )
        .receive(on: DispatchQueue.main)
        .sink(
            receiveCompletion: { [weak self] completion in
                self?.isLoading = false
                if case .failure(let error) = completion {
                    self?.errorMessage = error.localizedDescription
                }
            },
            receiveValue: { [weak self] response in
                if response.success, let categoryDTOs = response.data {
                    self?.categories = categoryDTOs.map(DataMapper.mapCategory)
                } else {
                    self?.errorMessage = response.message ?? "Failed to load categories"
                }
            }
        )
        .store(in: &cancellables)
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           11. SWIFTUI VIEWS AND SCREENS
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - Content View

struct ContentView: View {
    @EnvironmentObject var appState: AppState
    @EnvironmentObject var authService: AuthenticationService
    
    var body: some View {
        Group {
            if authService.isAuthenticated {
                MainTabView()
            } else {
                AuthenticationView()
            }
        }
        .overlay(
            Group {
                if let errorMessage = appState.errorMessage {
                    ErrorBannerView(message: errorMessage) {
                        appState.clearError()
                    }
                }
            }
        )
    }
}

// MARK: - Authentication View

struct AuthenticationView: View {
    @State private var isLoginMode = true
    
    var body: some View {
        NavigationView {
            VStack(spacing: 20) {
                // Logo or App Title
                VStack(spacing: 8) {
                    Image(systemName: "doc.text.fill")
                        .font(.system(size: 60))
                        .foregroundColor(.blue)
                    
                    Text("MyApp")
                        .font(.largeTitle)
                        .fontWeight(.bold)
                }
                .padding(.top, 60)
                
                Spacer()
                
                // Authentication Form
                if isLoginMode {
                    LoginView()
                } else {
                    RegisterView()
                }
                
                // Toggle between login and register
                Button(action: {
                    withAnimation(.easeInOut(duration: 0.3)) {
                        isLoginMode.toggle()
                    }
                }) {
                    Text(isLoginMode ? "Don't have an account? Sign up" : "Already have an account? Sign in")
                        .foregroundColor(.blue)
                        .padding()
                }
                
                Spacer()
            }
            .padding(.horizontal, 24)
            .navigationBarHidden(true)
        }
    }
}

// MARK: - Login View

struct LoginView: View {
    @EnvironmentObject var authService: AuthenticationService
    @State private var email = ""
    @State private var password = ""
    @State private var showPassword = false
    
    var body: some View {
        VStack(spacing: 16) {
            Text("Welcome Back")
                .font(.title2)
                .fontWeight(.semibold)
                .padding(.bottom, 20)
            
            // Email Field
            VStack(alignment: .leading, spacing: 8) {
                Text("Email")
                    .font(.caption)
                    .foregroundColor(.secondary)
                
                TextField("Enter your email", text: $email)
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                    .keyboardType(.emailAddress)
                    .autocapitalization(.none)
                    .disableAutocorrection(true)
            }
            
            // Password Field
            VStack(alignment: .leading, spacing: 8) {
                Text("Password")
                    .font(.caption)
                    .foregroundColor(.secondary)
                
                HStack {
                    if showPassword {
                        TextField("Enter your password", text: $password)
                    } else {
                        SecureField("Enter your password", text: $password)
                    }
                    
                    Button(action: {
                        showPassword.toggle()
                    }) {
                        Image(systemName: showPassword ? "eye.slash" : "eye")
                            .foregroundColor(.secondary)
                    }
                }
                .textFieldStyle(RoundedBorderTextFieldStyle())
            }
            
            // Login Button
            Button(action: {
                authService.login(email: email, password: password)
            }) {
                HStack {
                    if authService.isLoading {
                        ProgressView()
                            .progressViewStyle(CircularProgressViewStyle(tint: .white))
                            .scaleEffect(0.8)
                    } else {
                        Text("Sign In")
                            .fontWeight(.semibold)
                    }
                }
                .frame(maxWidth: .infinity)
                .padding()
                .background(Color.blue)
                .foregroundColor(.white)
                .cornerRadius(10)
            }
            .disabled(email.isEmpty || password.isEmpty || authService.isLoading)
            
            // Error Message
            if let errorMessage = authService.errorMessage {
                Text(errorMessage)
                    .foregroundColor(.red)
                    .font(.caption)
                    .multilineTextAlignment(.center)
                    .padding(.horizontal)
            }
        }
    }
}

// MARK: - Register View

struct RegisterView: View {
    @EnvironmentObject var authService: AuthenticationService
    @State private var email = ""
    @State private var username = ""
    @State private var firstName = ""
    @State private var lastName = ""
    @State private var password = ""
    @State private var confirmPassword = ""
    @State private var showPassword = false
    
    var isFormValid: Bool {
        !email.isEmpty && !username.isEmpty && !firstName.isEmpty && 
        !lastName.isEmpty && !password.isEmpty && password == confirmPassword && 
        password.count >= 8
    }
    
    var body: some View {
        ScrollView {
            VStack(spacing: 16) {
                Text("Create Account")
                    .font(.title2)
                    .fontWeight(.semibold)
                    .padding(.bottom, 20)
                
                // Name Fields
                HStack(spacing: 12) {
                    VStack(alignment: .leading, spacing: 8) {
                        Text("First Name")
                            .font(.caption)
                            .foregroundColor(.secondary)
                        TextField("First Name", text: $firstName)
                            .textFieldStyle(RoundedBorderTextFieldStyle())
                    }
                    
                    VStack(alignment: .leading, spacing: 8) {
                        Text("Last Name")
                            .font(.caption)
                            .foregroundColor(.secondary)
                        TextField("Last Name", text: $lastName)
                            .textFieldStyle(RoundedBorderTextFieldStyle())
                    }
                }
                
                // Email Field
                VStack(alignment: .leading, spacing: 8) {
                    Text("Email")
                        .font(.caption)
                        .foregroundColor(.secondary)
                    TextField("Enter your email", text: $email)
                        .textFieldStyle(RoundedBorderTextFieldStyle())
                        .keyboardType(.emailAddress)
                        .autocapitalization(.none)
                        .disableAutocorrection(true)
                }
                
                // Username Field
                VStack(alignment: .leading, spacing: 8) {
                    Text("Username")
                        .font(.caption)
                        .foregroundColor(.secondary)
                    TextField("Choose a username", text: $username)
                        .textFieldStyle(RoundedBorderTextFieldStyle())
                        .autocapitalization(.none)
                        .disableAutocorrection(true)
                }
                
                // Password Fields
                VStack(alignment: .leading, spacing: 8) {
                    Text("Password")
                        .font(.caption)
                        .foregroundColor(.secondary)
                    HStack {
                        if showPassword {
                            TextField("Enter your password", text: $password)
                        } else {
                            SecureField("Enter your password", text: $password)
                        }
                        
                        Button(action: {
                            showPassword.toggle()
                        }) {
                            Image(systemName: showPassword ? "eye.slash" : "eye")
                                .foregroundColor(.secondary)
                        }
                    }
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                }
                
                VStack(alignment: .leading, spacing: 8) {
                    Text("Confirm Password")
                        .font(.caption)
                        .foregroundColor(.secondary)
                    SecureField("Confirm your password", text: $confirmPassword)
                        .textFieldStyle(RoundedBorderTextFieldStyle())
                }
                
                // Password Requirements
                VStack(alignment: .leading, spacing: 4) {
                    Text("Password must:")
                        .font(.caption)
                        .foregroundColor(.secondary)
                    
                    HStack {
                        Image(systemName: password.count >= 8 ? "checkmark.circle.fill" : "circle")
                            .foregroundColor(password.count >= 8 ? .green : .secondary)
                        Text("Be at least 8 characters long")
                            .font(.caption)
                        Spacer()
                    }
                    
                    HStack {
                        Image(systemName: password == confirmPassword && !password.isEmpty ? "checkmark.circle.fill" : "circle")
                            .foregroundColor(password == confirmPassword && !password.isEmpty ? .green : .secondary)
                        Text("Match confirmation password")
                            .font(.caption)
                        Spacer()
                    }
                }
                .padding(.horizontal)
                
                // Register Button
                Button(action: {authService.register(
                        email: email,
                        username: username,
                        firstName: firstName,
                        lastName: lastName,
                        password: password
                    )
                }) {
                    HStack {
                        if authService.isLoading {
                            ProgressView()
                                .progressViewStyle(CircularProgressViewStyle(tint: .white))
                                .scaleEffect(0.8)
                        } else {
                            Text("Create Account")
                                .fontWeight(.semibold)
                        }
                    }
                    .frame(maxWidth: .infinity)
                    .padding()
                    .background(isFormValid ? Color.blue : Color.gray)
                    .foregroundColor(.white)
                    .cornerRadius(10)
                }
                .disabled(!isFormValid || authService.isLoading)
                
                // Error Message
                if let errorMessage = authService.errorMessage {
                    Text(errorMessage)
                        .foregroundColor(.red)
                        .font(.caption)
                        .multilineTextAlignment(.center)
                        .padding(.horizontal)
                }
            }
        }
    }
}

// MARK: - Main Tab View

struct MainTabView: View {
    @EnvironmentObject var appState: AppState
    
    var body: some View {
        TabView(selection: $appState.selectedTab) {
            PostsListView()
                .tabItem {
                    Image(systemName: AppState.Tab.posts.iconName)
                    Text(AppState.Tab.posts.rawValue)
                }
                .tag(AppState.Tab.posts)
            
            ExploreView()
                .tabItem {
                    Image(systemName: AppState.Tab.explore.iconName)
                    Text(AppState.Tab.explore.rawValue)
                }
                .tag(AppState.Tab.explore)
            
            FavoritesView()
                .tabItem {
                    Image(systemName: AppState.Tab.favorites.iconName)
                    Text(AppState.Tab.favorites.rawValue)
                }
                .tag(AppState.Tab.favorites)
            
            ProfileView()
                .tabItem {
                    Image(systemName: AppState.Tab.profile.iconName)
                    Text(AppState.Tab.profile.rawValue)
                }
                .tag(AppState.Tab.profile)
        }
        .accentColor(.blue)
    }
}

// MARK: - Posts List View

struct PostsListView: View {
    @StateObject private var viewModel = PostsViewModel()
    @StateObject private var categoriesViewModel = CategoriesViewModel()
    @State private var showingCreatePost = false
    
    var body: some View {
        NavigationView {
            VStack(spacing: 0) {
                // Search Bar
                SearchBar(text: $viewModel.searchText)
                    .padding(.horizontal)
                    .padding(.top, 8)
                
                // Category Filter
                if !categoriesViewModel.categories.isEmpty {
                    CategoryFilterView(
                        categories: categoriesViewModel.categories,
                        selectedCategory: $viewModel.selectedCategory
                    )
                    .padding(.horizontal)
                }
                
                // Posts List
                if viewModel.posts.isEmpty && !viewModel.isLoading {
                    EmptyStateView(
                        title: "No Posts Yet",
                        subtitle: "Start by creating your first post",
                        imageName: "doc.text.badge.plus"
                    )
                } else {
                    List {
                        ForEach(viewModel.posts) { post in
                            NavigationLink(destination: PostDetailView(postID: post.id)) {
                                PostRowView(post: post) {
                                    viewModel.likePost(post)
                                }
                            }
                            .buttonStyle(PlainButtonStyle())
                            
                            // Load more when reaching the end
                            if post == viewModel.posts.last && viewModel.hasMorePages {
                                ProgressView()
                                    .frame(maxWidth: .infinity)
                                    .onAppear {
                                        viewModel.loadMorePosts()
                                    }
                            }
                        }
                    }
                    .listStyle(PlainListStyle())
                    .refreshable {
                        viewModel.refreshPosts()
                    }
                }
            }
            .navigationTitle("Posts")
            .navigationBarTitleDisplayMode(.large)
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: { showingCreatePost = true }) {
                        Image(systemName: "plus")
                    }
                }
            }
            .sheet(isPresented: $showingCreatePost) {
                CreatePostView()
            }
            .overlay(
                Group {
                    if viewModel.isLoading && viewModel.posts.isEmpty {
                        ProgressView("Loading posts...")
                    }
                }
            )
        }
        .onAppear {
            if viewModel.posts.isEmpty {
                viewModel.loadPosts()
            }
        }
        .alert("Error", isPresented: .constant(viewModel.errorMessage != nil)) {
            Button("OK") {
                viewModel.clearError()
            }
        } message: {
            if let errorMessage = viewModel.errorMessage {
                Text(errorMessage)
            }
        }
    }
}

// MARK: - Post Row View

struct PostRowView: View {
    let post: Post
    let onLike: () -> Void
    
    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            // Header with author info
            HStack {
                AsyncImage(url: post.author?.avatarURL) { image in
                    image
                        .resizable()
                        .aspectRatio(contentMode: .fill)
                } placeholder: {
                    Circle()
                        .fill(Color.gray.opacity(0.3))
                        .overlay(
                            Text(post.author?.initials ?? "??")
                                .font(.caption)
                                .foregroundColor(.secondary)
                        )
                }
                .frame(width: 32, height: 32)
                .clipShape(Circle())
                
                VStack(alignment: .leading, spacing: 2) {
                    Text(post.author?.fullName ?? "Unknown Author")
                        .font(.caption)
                        .fontWeight(.medium)
                    
                    Text(post.formattedPublishDate)
                        .font(.caption2)
                        .foregroundColor(.secondary)
                }
                
                Spacer()
                
                if let category = post.category {
                    CategoryBadge(category: category)
                }
            }
            
            // Post content
            VStack(alignment: .leading, spacing: 8) {
                Text(post.title)
                    .font(.headline)
                    .fontWeight(.semibold)
                    .lineLimit(2)
                
                Text(post.excerpt)
                    .font(.body)
                    .foregroundColor(.secondary)
                    .lineLimit(3)
            }
            
            // Post image if available
            if let imageURL = post.imageURL {
                AsyncImage(url: imageURL) { image in
                    image
                        .resizable()
                        .aspectRatio(contentMode: .fill)
                } placeholder: {
                    Rectangle()
                        .fill(Color.gray.opacity(0.2))
                        .overlay(
                            ProgressView()
                        )
                }
                .frame(height: 180)
                .clipShape(RoundedRectangle(cornerRadius: 8))
            }
            
            // Tags
            if !post.tags.isEmpty {
                ScrollView(.horizontal, showsIndicators: false) {
                    HStack(spacing: 8) {
                        ForEach(post.tags, id: \.self) { tag in
                            TagView(tag: tag)
                        }
                    }
                    .padding(.horizontal, 1)
                }
            }
            
            // Action buttons
            HStack(spacing: 24) {
                Button(action: onLike) {
                    HStack(spacing: 4) {
                        Image(systemName: post.isLiked ? "heart.fill" : "heart")
                            .foregroundColor(post.isLiked ? .red : .secondary)
                        Text("\(post.likeCount)")
                            .font(.caption)
                            .foregroundColor(.secondary)
                    }
                }
                
                HStack(spacing: 4) {
                    Image(systemName: "bubble.left")
                        .foregroundColor(.secondary)
                    Text("\(post.commentCount)")
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
                
                HStack(spacing: 4) {
                    Image(systemName: "eye")
                        .foregroundColor(.secondary)
                    Text("\(post.viewCount)")
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
                
                Spacer()
                
                Text("\(post.readingTimeMinutes) min read")
                    .font(.caption2)
                    .foregroundColor(.secondary)
            }
        }
        .padding(.vertical, 8)
    }
}

// MARK: - Post Detail View

struct PostDetailView: View {
    let postID: String
    @StateObject private var viewModel: PostDetailViewModel
    @Environment(\.presentationMode) var presentationMode
    
    init(postID: String) {
        self.postID = postID
        self._viewModel = StateObject(wrappedValue: PostDetailViewModel(postID: postID))
    }
    
    var body: some View {
        ScrollView {
            if let post = viewModel.post {
                VStack(alignment: .leading, spacing: 20) {
                    // Header
                    VStack(alignment: .leading, spacing: 12) {
                        Text(post.title)
                            .font(.largeTitle)
                            .fontWeight(.bold)
                            .lineLimit(nil)
                        
                        HStack {
                            AsyncImage(url: post.author?.avatarURL) { image in
                                image
                                    .resizable()
                                    .aspectRatio(contentMode: .fill)
                            } placeholder: {
                                Circle()
                                    .fill(Color.gray.opacity(0.3))
                                    .overlay(
                                        Text(post.author?.initials ?? "??")
                                            .font(.caption)
                                            .foregroundColor(.secondary)
                                    )
                            }
                            .frame(width: 40, height: 40)
                            .clipShape(Circle())
                            
                            VStack(alignment: .leading, spacing: 2) {
                                Text(post.author?.fullName ?? "Unknown Author")
                                    .font(.subheadline)
                                    .fontWeight(.medium)
                                
                                HStack(spacing: 8) {
                                    Text(post.formattedPublishDate)
                                        .font(.caption)
                                        .foregroundColor(.secondary)
                                    
                                    Text("•")
                                        .foregroundColor(.secondary)
                                    
                                    Text("\(post.readingTimeMinutes) min read")
                                        .font(.caption)
                                        .foregroundColor(.secondary)
                                }
                            }
                            
                            Spacer()
                        }
                    }
                    
                    // Featured Image
                    if let imageURL = post.imageURL {
                        AsyncImage(url: imageURL) { image in
                            image
                                .resizable()
                                .aspectRatio(contentMode: .fill)
                        } placeholder: {
                            Rectangle()
                                .fill(Color.gray.opacity(0.2))
                                .overlay(ProgressView())
                        }
                        .frame(height: 220)
                        .clipShape(RoundedRectangle(cornerRadius: 12))
                    }
                    
                    // Content
                    Text(post.content)
                        .font(.body)
                        .lineSpacing(6)
                    
                    // Tags
                    if !post.tags.isEmpty {
                        VStack(alignment: .leading, spacing: 8) {
                            Text("Tags")
                                .font(.headline)
                                .fontWeight(.semibold)
                            
                            FlowLayout(spacing: 8) {
                                ForEach(post.tags, id: \.self) { tag in
                                    TagView(tag: tag)
                                }
                            }
                        }
                    }
                    
                    Divider()
                    
                    // Action Bar
                    HStack(spacing: 24) {
                        Button(action: {
                            viewModel.likePost()
                        }) {
                            HStack(spacing: 6) {
                                Image(systemName: post.isLiked ? "heart.fill" : "heart")
                                    .foregroundColor(post.isLiked ? .red : .primary)
                                Text("\(post.likeCount)")
                                    .foregroundColor(.primary)
                            }
                            .font(.subheadline)
                            .fontWeight(.medium)
                        }
                        
                        Button(action: {}) {
                            HStack(spacing: 6) {
                                Image(systemName: "bubble.left")
                                Text("\(post.commentCount)")
                            }
                            .font(.subheadline)
                            .fontWeight(.medium)
                            .foregroundColor(.primary)
                        }
                        
                        Button(action: {}) {
                            Image(systemName: "square.and.arrow.up")
                                .font(.subheadline)
                                .fontWeight(.medium)
                        }
                        
                        Spacer()
                    }
                    
                    Divider()
                    
                    // Comments Section
                    CommentsSection(comments: viewModel.comments)
                }
                .padding()
            }
        }
        .navigationBarTitleDisplayMode(.inline)
        .overlay(
            Group {
                if viewModel.isLoading {
                    ProgressView("Loading post...")
                }
            }
        )
        .alert("Error", isPresented: .constant(viewModel.errorMessage != nil)) {
            Button("OK") {
                viewModel.clearError()
            }
        } message: {
            if let errorMessage = viewModel.errorMessage {
                Text(errorMessage)
            }
        }
    }
}

// MARK: - Supporting Views

struct SearchBar: View {
    @Binding var text: String
    
    var body: some View {
        HStack {
            Image(systemName: "magnifyingglass")
                .foregroundColor(.secondary)
            
            TextField("Search posts...", text: $text)
                .textFieldStyle(PlainTextFieldStyle())
            
            if !text.isEmpty {
                Button(action: { text = "" }) {
                    Image(systemName: "xmark.circle.fill")
                        .foregroundColor(.secondary)
                }
            }
        }
        .padding(.horizontal, 12)
        .padding(.vertical, 8)
        .background(Color(.systemGray6))
        .cornerRadius(10)
    }
}

struct CategoryFilterView: View {
    let categories: [Category]
    @Binding var selectedCategory: Category?
    
    var body: some View {
        ScrollView(.horizontal, showsIndicators: false) {
            HStack(spacing: 12) {
                // All categories button
                Button(action: { selectedCategory = nil }) {
                    Text("All")
                        .font(.subheadline)
                        .fontWeight(.medium)
                        .padding(.horizontal, 16)
                        .padding(.vertical, 8)
                        .background(selectedCategory == nil ? Color.blue : Color.clear)
                        .foregroundColor(selectedCategory == nil ? .white : .blue)
                        .overlay(
                            RoundedRectangle(cornerRadius: 20)
                                .stroke(Color.blue, lineWidth: 1)
                        )
                        .cornerRadius(20)
                }
                
                ForEach(categories) { category in
                    Button(action: { selectedCategory = category }) {
                        Text(category.name)
                            .font(.subheadline)
                            .fontWeight(.medium)
                            .padding(.horizontal, 16)
                            .padding(.vertical, 8)
                            .background(selectedCategory?.id == category.id ? category.colorValue : Color.clear)
                            .foregroundColor(selectedCategory?.id == category.id ? .white : category.colorValue)
                            .overlay(
                                RoundedRectangle(cornerRadius: 20)
                                    .stroke(category.colorValue, lineWidth: 1)
                            )
                            .cornerRadius(20)
                    }
                }
            }
            .padding(.horizontal)
        }
        .padding(.vertical, 8)
    }
}

struct CategoryBadge: View {
    let category: Category
    
    var body: some View {
        Text(category.name)
            .font(.caption2)
            .fontWeight(.semibold)
            .padding(.horizontal, 8)
            .padding(.vertical, 4)
            .background(category.colorValue.opacity(0.2))
            .foregroundColor(category.colorValue)
            .cornerRadius(8)
    }
}

struct TagView: View {
    let tag: String
    
    var body: some View {
        Text("#\(tag)")
            .font(.caption)
            .padding(.horizontal, 8)
            .padding(.vertical, 4)
            .background(Color(.systemGray6))
            .foregroundColor(.secondary)
            .cornerRadius(6)
    }
}

struct EmptyStateView: View {
    let title: String
    let subtitle: String
    let imageName: String
    
    var body: some View {
        VStack(spacing: 16) {
            Image(systemName: imageName)
                .font(.system(size: 60))
                .foregroundColor(.secondary)
            
            VStack(spacing: 8) {
                Text(title)
                    .font(.title2)
                    .fontWeight(.semibold)
                
                Text(subtitle)
                    .font(.body)
                    .foregroundColor(.secondary)
                    .multilineTextAlignment(.center)
            }
        }
        .padding()
    }
}

struct ErrorBannerView: View {
    let message: String
    let onDismiss: () -> Void
    
    var body: some View {
        VStack {
            HStack {
                Image(systemName: "exclamationmark.triangle.fill")
                    .foregroundColor(.white)
                
                Text(message)
                    .foregroundColor(.white)
                    .font(.subheadline)
                
                Spacer()
                
                Button(action: onDismiss) {
                    Image(systemName: "xmark")
                        .foregroundColor(.white)
                }
            }
            .padding()
            .background(Color.red)
            
            Spacer()
        }
        .ignoresSafeArea()
    }
}

// MARK: - Flow Layout for Tags

struct FlowLayout: Layout {
    let spacing: CGFloat
    
    init(spacing: CGFloat = 8) {
        self.spacing = spacing
    }
    
    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        let sizes = subviews.map { $0.sizeThatFits(.unspecified) }
        
        var totalHeight: CGFloat = 0
        var currentRowWidth: CGFloat = 0
        var currentRowHeight: CGFloat = 0
        
        for size in sizes {
            if currentRowWidth + size.width > (proposal.width ?? .infinity) {
                totalHeight += currentRowHeight + spacing
                currentRowWidth = size.width
                currentRowHeight = size.height
            } else {
                currentRowWidth += size.width + spacing
                currentRowHeight = max(currentRowHeight, size.height)
            }
        }
        
        totalHeight += currentRowHeight
        
        return CGSize(width: proposal.width ?? currentRowWidth, height: totalHeight)
    }
    
    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        let sizes = subviews.map { $0.sizeThatFits(.unspecified) }
        
        var currentX: CGFloat = bounds.minX
        var currentY: CGFloat = bounds.minY
        var currentRowHeight: CGFloat = 0
        
        for (index, subview) in subviews.enumerated() {
            let size = sizes[index]
            
            if currentX + size.width > bounds.maxX && currentX > bounds.minX {
                currentX = bounds.minX
                currentY += currentRowHeight + spacing
                currentRowHeight = 0
            }
            
            subview.place(
                at: CGPoint(x: currentX, y: currentY),
                proposal: ProposedViewSize(size)
            )
            
            currentX += size.width + spacing
            currentRowHeight = max(currentRowHeight, size.height)
        }
    }
}

// MARK: - Additional Views

struct ExploreView: View {
    var body: some View {
        NavigationView {
            VStack {
                Text("Explore")
                    .font(.largeTitle)
                    .fontWeight(.bold)
                Spacer()
                Text("Discover new content here")
                    .foregroundColor(.secondary)
                Spacer()
            }
            .navigationTitle("Explore")
        }
    }
}

struct FavoritesView: View {
    var body: some View {
        NavigationView {
            VStack {
                Text("Favorites")
                    .font(.largeTitle)
                    .fontWeight(.bold)
                Spacer()
                Text("Your saved posts appear here")
                    .foregroundColor(.secondary)
                Spacer()
            }
            .navigationTitle("Favorites")
        }
    }
}

struct ProfileView: View {
    @EnvironmentObject var authService: AuthenticationService
    
    var body: some View {
        NavigationView {
            VStack(spacing: 20) {
                if let user = authService.currentUser {
                    AsyncImage(url: user.avatarURL) { image in
                        image
                            .resizable()
                            .aspectRatio(contentMode: .fill)
                    } placeholder: {
                        Circle()
                            .fill(Color.gray.opacity(0.3))
                            .overlay(
                                Text(user.initials)
                                    .font(.title)
                                    .foregroundColor(.white)
                            )
                    }
                    .frame(width: 100, height: 100)
                    .clipShape(Circle())
                    
                    Text(user.fullName)
                        .font(.title2)
                        .fontWeight(.semibold)
                    
                    Text("@\(user.username)")
                        .foregroundColor(.secondary)
                    
                    if let bio = user.bio {
                        Text(bio)
                            .multilineTextAlignment(.center)
                            .padding(.horizontal)
                    }
                    
                    Spacer()
                    
                    Button("Logout") {
                        authService.logout()
                    }
                    .foregroundColor(.red)
                }
            }
            .padding()
            .navigationTitle("Profile")
        }
    }
}

struct CreatePostView: View {
    @Environment(\.presentationMode) var presentationMode
    @State private var title = ""
    @State private var content = ""
    @State private var isPublished = false
    
    var body: some View {
        NavigationView {
            VStack(spacing: 20) {
                TextField("Post title", text: $title)
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                
                TextEditor(text: $content)
                    .padding(8)
                    .overlay(
                        RoundedRectangle(cornerRadius: 8)
                            .stroke(Color.gray.opacity(0.3))
                    )
                
                Toggle("Publish immediately", isOn: $isPublished)
                
                Spacer()
            }
            .padding()
            .navigationTitle("New Post")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .navigationBarLeading) {
                    Button("Cancel") {
                        presentationMode.wrappedValue.dismiss()
                    }
                }
                
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button("Save") {
                        // Handle save
                        presentationMode.wrappedValue.dismiss()
                    }
                    .disabled(title.isEmpty || content.isEmpty)
                }
            }
        }
    }
}

struct CommentsSection: View {
    let comments: [Comment]
    
    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
            Text("Comments (\(comments.count))")
                .font(.headline)
                .fontWeight(.semibold)
            
            if comments.isEmpty {
                Text("No comments yet")
                    .foregroundColor(.secondary)
                    .italic()
            } else {
                ForEach(comments) { comment in
                    CommentView(comment: comment)
                }
            }
        }
    }
}

struct CommentView: View {
    let comment: Comment
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            HStack {
                Text(comment.author?.fullName ?? "Anonymous")
                    .font(.subheadline)
                    .fontWeight(.medium)
                
                Spacer()
                
                Text(comment.timeAgo)
                    .font(.caption)
                    .foregroundColor(.secondary)
            }
            
            Text(comment.content)
                .font(.body)
        }
        .padding()
        .background(Color(.systemGray6))
        .cornerRadius(8)
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           12. UTILITY EXTENSIONS
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - Date Extensions

extension DateFormatter {
    static let iso8601: DateFormatter = {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSS'Z'"
        formatter.timeZone = TimeZone(secondsFromGMT: 0)
        formatter.locale = Locale(identifier: "en_US_POSIX")
        return formatter
    }()
    
    static let mediumDate: DateFormatter = {
        let formatter = DateFormatter()
        formatter.dateStyle = .medium
        return formatter
    }()
}

extension Date {
    func timeAgoDisplay() -> String {
        let now = Date()
        let components = Calendar.current.dateComponents([.second, .minute, .hour, .day, .weekOfYear, .month, .year], from: self, to: now)
        
        if let year = components.year, year >= 1 {
            return "\(year) year\(year == 1 ? "" : "s") ago"
        }
        
        if let month = components.month, month >= 1 {
            return "\(month) month\(month == 1 ? "" : "s") ago"
        }
        
        if let week = components.weekOfYear, week >= 1 {
            return "\(week) week\(week == 1 ? "" : "s") ago"
        }
        
        if let day = components.day, day >= 1 {
            return "\(day) day\(day == 1 ? "" : "s") ago"
        }
        
        if let hour = components.hour, hour >= 1 {
            return "\(hour) hour\(hour == 1 ? "" : "s") ago"
        }
        
        if let minute = components.minute, minute >= 1 {
            return "\(minute) minute\(minute == 1 ? "" : "s") ago"
        }
        
        return "Just now"
    }
}

// MARK: - Color Extensions

extension Color {
    init?(hex: String) {
        let hex = hex.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
        var int: UInt64 = 0
        
        Scanner(string: hex).scanHexInt64(&int)
        
        let a, r, g, b: UInt64
        switch hex.count {
        case 3: // RGB (12-bit)
            (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
        case 6: // RGB (24-bit)
            (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
        case 8: // ARGB (32-bit)
            (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
        default:
            return nil
        }
        
        self.init(
            .sRGB,
            red: Double(r) / 255,
            green: Double(g) / 255,
            blue: Double(b) / 255,
            opacity: Double(a) / 255
        )
    }
}

// MARK: - Codable Extensions

extension Encodable {
    func asDictionary() throws -> [String: Any] {
        let data = try JSONEncoder().encode(self)
        guard let dictionary = try JSONSerialization.jsonObject(with: data, options: .allowFragments) as? [String: Any] else {
            throw NSError()
        }
        return dictionary
    }
}


// ═══════════════════════════════════════════════════════════════════════════════
//                           13. ADDITIONAL SERVICES
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - Network Monitor

import Network

class NetworkMonitor: ObservableObject {
    private let monitor = NWPathMonitor()
    private let queue = DispatchQueue(label: "NetworkMonitor")
    
    @Published var isConnected = false
    @Published var connectionType: ConnectionType = .unknown
    
    enum ConnectionType {
        case wifi
        case cellular
        case ethernet
        case unknown
    }
    
    init() {
        startMonitoring()
    }
    
    private func startMonitoring() {
        monitor.pathUpdateHandler = { [weak self] path in
            DispatchQueue.main.async {
                self?.isConnected = path.status == .satisfied
                self?.getConnectionType(path)
            }
        }
        monitor.start(queue: queue)
    }
    
    private func getConnectionType(_ path: NWPath) {
        if path.usesInterfaceType(.wifi) {
            connectionType = .wifi
        } else if path.usesInterfaceType(.cellular) {
            connectionType = .cellular
        } else if path.usesInterfaceType(.wiredEthernet) {
            connectionType = .ethernet
        } else {
            connectionType = .unknown
        }
    }
    
    deinit {
        monitor.cancel()
    }
}

// MARK: - Analytics Manager

class AnalyticsManager {
    static let shared = AnalyticsManager()
    
    private init() {}
    
    func initialize() {
        // Initialize analytics services (Firebase, Mixpanel, etc.)
        print("Analytics initialized")
    }
    
    func track(event: String, parameters: [String: Any]? = nil) {
        // Track analytics events
        print("Analytics event: \(event), parameters: \(parameters ?? [:])")
    }
    
    func setUserProperty(key: String, value: String) {
        // Set user properties for analytics
        print("User property set: \(key) = \(value)")
    }
    
    func identify(userID: String) {
        // Identify user for analytics
        print("User identified: \(userID)")
    }
}

// MARK: - Image Cache Manager

import UIKit

class ImageCacheManager {
    static let shared = ImageCacheManager()
    
    private let cache = NSCache<NSString, UIImage>()
    private let session = URLSession.shared
    
    private init() {
        cache.countLimit = 100
        cache.totalCostLimit = 1024 * 1024 * 100 // 100 MB
    }
    
    func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {
        let key = NSString(string: url.absoluteString)
        
        // Check cache first
        if let cachedImage = cache.object(forKey: key) {
            completion(cachedImage)
            return
        }
        
        // Download image
        session.dataTask(with: url) { [weak self] data, response, error in
            guard let data = data,
                  let image = UIImage(data: data),
                  error == nil else {
                DispatchQueue.main.async {
                    completion(nil)
                }
                return
            }
            
            // Cache the image
            self?.cache.setObject(image, forKey: key)
            
            DispatchQueue.main.async {
                completion(image)
            }
        }.resume()
    }
    
    func clearCache() {
        cache.removeAllObjects()
    }
}

// MARK: - Notification Manager

import UserNotifications

class NotificationManager: NSObject, UNUserNotificationCenterDelegate {
    static let shared = NotificationManager()
    
    override init() {
        super.init()
        UNUserNotificationCenter.current().delegate = self
    }
    
    func requestPermissions() {
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in
            if granted {
                DispatchQueue.main.async {
                    UIApplication.shared.registerForRemoteNotifications()
                }
            }
        }
    }
    
    func scheduleLocalNotification(title: String, body: String, timeInterval: TimeInterval) {
        let content = UNMutableNotificationContent()
        content.title = title
        content.body = body
        content.sound = .default
        
        let trigger = UNTimeIntervalNotificationTrigger(timeInterval: timeInterval, repeats: false)
        let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: trigger)
        
        UNUserNotificationCenter.current().add(request)
    }
    
    // MARK: - UNUserNotificationCenterDelegate
    
    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        completionHandler([.alert, .badge, .sound])
    }
    
    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        // Handle notification tap
        completionHandler()
    }
}

// MARK: - Location Manager

import CoreLocation

class LocationManager: NSObject, ObservableObject, CLLocationManagerDelegate {
    private let manager = CLLocationManager()
    
    @Published var location: CLLocation?
    @Published var authorizationStatus: CLAuthorizationStatus = .notDetermined
    
    override init() {
        super.init()
        manager.delegate = self
        manager.desiredAccuracy = kCLLocationAccuracyBest
    }
    
    func requestPermission() {
        manager.requestWhenInUseAuthorization()
    }
    
    func startLocationUpdates() {
        guard authorizationStatus == .authorizedWhenInUse || authorizationStatus == .authorizedAlways else {
            return
        }
        manager.startUpdatingLocation()
    }
    
    func stopLocationUpdates() {
        manager.stopUpdatingLocation()
    }
    
    // MARK: - CLLocationManagerDelegate
    
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        location = locations.last
    }
    
    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        print("Location error: \(error.localizedDescription)")
    }
    
    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
        authorizationStatus = manager.authorizationStatus
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           14. TESTING SUPPORT
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - Mock Data

#if DEBUG
extension User {
    static let mock = User(
        id: "1",
        email: "john@example.com",
        username: "johndoe",
        firstName: "John",
        lastName: "Doe",
        avatarURL: URL(string: "https://via.placeholder.com/150"),
        bio: "iOS Developer passionate about Swift and SwiftUI",
        isActive: true,
        createdAt: Date(),
        updatedAt: Date()
    )
}

extension Post {
    static let mock = Post(
        id: "1",
        title: "Getting Started with SwiftUI",
        content: "SwiftUI is a powerful framework for building user interfaces across all Apple platforms. In this post, we'll explore the basics of SwiftUI and how to create your first app...",
        excerpt: "Learn the fundamentals of SwiftUI and start building modern iOS apps",
        imageURL: URL(string: "https://via.placeholder.com/400x200"),
        authorID: "1",
        author: User.mock,
        categoryID: "1",
        category: Category.mock,
        tags: ["SwiftUI", "iOS", "Tutorial"],
        isPublished: true,
        viewCount: 256,
        likeCount: 42,
        commentCount: 8,
        isLiked: false,
        publishedAt: Date(),
        createdAt: Date(),
        updatedAt: Date()
    )
}

extension Category {
    static let mock = Category(
        id: "1",
        name: "iOS Development",
        slug: "ios-development",
        description: "Everything related to iOS app development",
        color: "#007AFF",
        postCount: 25
    )
}
#endif

// MARK: - Test Utilities

class MockNetworkManager: NetworkManager {
    var shouldReturnError = false
    var mockResponse: Any?
    
    override func request<T: Codable>(endpoint: APIEndpoint, responseType: T.Type, completion: @escaping (Result<T, NetworkError>) -> Void) {
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
            if self.shouldReturnError {
                completion(.failure(.networkError("Mock error")))
            } else if let mockResponse = self.mockResponse as? T {
                completion(.success(mockResponse))
            } else {
                completion(.failure(.noData))
            }
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           15. APP CONFIGURATION AND CONSTANTS
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - App Configuration

enum AppConfiguration {
    static let appName = "MyApp"
    static let appVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "1.0"
    static let buildNumber = Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "1"
    
    enum API {
        static let baseURL = "https://api.example.com/v1"
        static let timeout: TimeInterval = 30
    }
    
    enum Cache {
        static let maxImageCacheSize = 100 * 1024 * 1024 // 100 MB
        static let maxImageCacheCount = 100
    }
    
    enum Animation {
        static let defaultDuration: TimeInterval = 0.3
        static let springAnimation = Animation.spring(response: 0.5, dampingFraction: 0.8)
    }
}

// MARK: - Constants

enum Constants {
    enum Spacing {
        static let xs: CGFloat = 4
        static let sm: CGFloat = 8
        static let md: CGFloat = 16
        static let lg: CGFloat = 24
        static let xl: CGFloat = 32
    }
    
    enum CornerRadius {
        static let sm: CGFloat = 4
        static let md: CGFloat = 8
        static let lg: CGFloat = 12
        static let xl: CGFloat = 16
    }
    
    enum FontSize {
        static let caption: CGFloat = 12
        static let body: CGFloat = 16
        static let headline: CGFloat = 20
        static let title: CGFloat = 24
        static let largeTitle: CGFloat = 32
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           16. DEPLOYMENT AND BUILD CONFIGURATION
// ═══════════════════════════════════════════════════════════════════════════════

/*
DEPLOYMENT CONFIGURATION:

1. Build Configurations:
   - Debug: Development builds with logging and debug features
   - Release: Production builds optimized for App Store
   - Staging: Testing builds for QA environment

2. Info.plist Configuration:
   - App Transport Security settings
   - URL schemes for deep linking
   - Background modes (if needed)
   - Privacy usage descriptions

3. Entitlements:
   - App Groups (for sharing data between app extensions)
   - Keychain sharing
   - Push notifications
   - Sign in with Apple

4. Build Scripts:
   - SwiftLint for code quality
   - SwiftGen for resource generation
   - Version bumping scripts

5. App Store Connect:
   - App icons and screenshots
   - App Store metadata
   - TestFlight distribution
   - App Store review guidelines compliance

6. Continuous Integration:
   - Automated testing
   - Code coverage reports
   - Automated deployment to TestFlight

EXAMPLE BUILD SCRIPT:
#!/bin/bash
# Increment build number
agvtool next-version -all
# Run tests
xcodebuild test -project MyApp.xcodeproj -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 15'
# Archive for distribution
xcodebuild archive -project MyApp.xcodeproj -scheme MyApp -archivePath build/MyApp.xcarchive
# Export IPA
xcodebuild -exportArchive -archivePath build/MyApp.xcarchive -exportPath build/ -exportOptionsPlist ExportOptions.plist
*/

// MARK: - Environment Configuration

enum Environment {
    case development
    case staging
    case production
    
    static var current: Environment {
        #if DEBUG
        return .development
        #elseif STAGING
        return .staging
        #else
        return .production
        #endif
    }
    
    var apiBaseURL: String {
        switch self {
        case .development:
            return "https://dev-api.example.com/v1"
        case .staging:
            return "https://staging-api.example.com/v1"
        case .production:
            return "https://api.example.com/v1"
        }
    }
    
    var analyticsEnabled: Bool {
        switch self {
        case .development:
            return false
        case .staging, .production:
            return true
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           17. ACCESSIBILITY SUPPORT
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - Accessibility Extensions

extension View {
    func accessibilityLabel(_ label: String) -> some View {
        self.accessibility(label: Text(label))
    }
    
    func accessibilityHint(_ hint: String) -> some View {
        self.accessibility(hint: Text(hint))
    }
    
    func accessibilityValue(_ value: String) -> some View {
        self.accessibility(value: Text(value))
    }
}

// MARK: - Accessibility Constants

enum AccessibilityIdentifiers {
    enum Authentication {
        static let emailField = "email_field"
        static let passwordField = "password_field"
        static let loginButton = "login_button"
        static let registerButton = "register_button"
    }
    
    enum Posts {
        static let postsList = "posts_list"
        static let postRow = "post_row"
        static let likeButton = "like_button"
        static let searchBar = "search_bar"
    }
    
    enum Navigation {
        static let tabBar = "main_tab_bar"
        static let postsTab = "posts_tab"
        static let exploreTab = "explore_tab"
        static let favoritesTab = "favorites_tab"
        static let profileTab = "profile_tab"
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           18. LOCALIZATION SUPPORT
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - Localization

enum LocalizedString {
    case loginTitle
    case emailPlaceholder
    case passwordPlaceholder
    case loginButton
    case registerButton
    case postsTitle
    case searchPlaceholder
    case errorTitle
    case loadingMessage
    
    var localized: String {
        switch self {
        case .loginTitle:
            return NSLocalizedString("login.title", value: "Welcome Back", comment: "Login screen title")
        case .emailPlaceholder:
            return NSLocalizedString("email.placeholder", value: "Enter your email", comment: "Email field placeholder")
        case .passwordPlaceholder:
            return NSLocalizedString("password.placeholder", value: "Enter your password", comment: "Password field placeholder")
        case .loginButton:
            return NSLocalizedString("login.button", value: "Sign In", comment: "Login button text")
        case .registerButton:
            return NSLocalizedString("register.button", value: "Create Account", comment: "Register button text")
        case .postsTitle:
            return NSLocalizedString("posts.title", value: "Posts", comment: "Posts screen title")
        case .searchPlaceholder:
            return NSLocalizedString("search.placeholder", value: "Search posts...", comment: "Search bar placeholder")
        case .errorTitle:
            return NSLocalizedString("error.title", value: "Error", comment: "Error alert title")
        case .loadingMessage:
            return NSLocalizedString("loading.message", value: "Loading...", comment: "Loading message")
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                           19. PREVIEW PROVIDERS AND DEVELOPMENT
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - SwiftUI Previews

#if DEBUG
struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
            .environmentObject(AppState())
            .environmentObject(AuthenticationService())
            .environmentObject(NetworkMonitor())
    }
}

struct PostRowView_Previews: PreviewProvider {
    static var previews: some View {
        PostRowView(post: Post.mock) {
            print("Like tapped")
        }
        .padding()
        .previewLayout(.sizeThatFits)
    }
}

struct LoginView_Previews: PreviewProvider {
    static var previews: some View {
        LoginView()
            .environmentObject(AuthenticationService())
            .previewLayout(.sizeThatFits)
    }
}
#endif

// ═══════════════════════════════════════════════════════════════════════════════
//                           20. PERFORMANCE OPTIMIZATION
// ═══════════════════════════════════════════════════════════════════════════════

// MARK: - Performance Utilities

class PerformanceMonitor {
    static let shared = PerformanceMonitor()
    
    private init() {}
    
    func measureTime<T>(operation: () throws -> T) rethrows -> (result: T, time: TimeInterval) {
        let startTime = CFAbsoluteTimeGetCurrent()
        let result = try operation()
        let timeElapsed = CFAbsoluteTimeGetCurrent() - startTime
        return (result, timeElapsed)
    }
    
    func logMemoryUsage() {
        let memoryInfo = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
        
        let kerr: kern_return_t = withUnsafeMutablePointer(to: &memoryInfo) {
            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
                task_info(mach_task_self_,
                         task_flavor_t(MACH_TASK_BASIC_INFO),
                         $0,
                         &count)
            }
        }
        
        if kerr == KERN_SUCCESS {
            let memoryUsage = Double(memoryInfo.resident_size) / 1024 / 1024
            print("Memory usage: \(memoryUsage) MB")
        }
    }
}

// MARK: - Image Optimization

extension Image {
    func optimizedForThumbnail() -> some View {
        self
            .resizable()
            .aspectRatio(contentMode: .fill)
            .clipped()
    }
    
    func optimizedForHero() -> some View {
        self
            .resizable()
            .aspectRatio(contentMode: .fit)
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
//                     FINAL NOTES AND DEVELOPMENT BEST PRACTICES
// ═══════════════════════════════════════════════════════════════════════════════

/*
SWIFT IOS DEVELOPMENT BEST PRACTICES:

1. ARCHITECTURE:
   - Use MVVM pattern with SwiftUI
   - Implement proper separation of concerns
   - Use dependency injection for testability
   - Follow SOLID principles

2. CODE QUALITY:
   - Use SwiftLint for consistent code style
   - Write comprehensive unit tests
   - Implement proper error handling
   - Use type-safe networking with Codable

3. PERFORMANCE:
   - Implement efficient image caching
   - Use lazy loading for large datasets
   - Optimize Core Data queries
   - Monitor memory usage and prevent leaks

4. SECURITY:
   - Store sensitive data in Keychain
   - Implement proper authentication
   - Use HTTPS for all network requests
   - Validate all user inputs

5. USER EXPERIENCE:
   - Implement proper loading states
   - Handle offline scenarios gracefully
   - Provide meaningful error messages
   - Support accessibility features

6. DEPLOYMENT:
   - Use proper build configurations
   - Implement continuous integration
   - Follow App Store guidelines
   - Test on multiple devices and iOS versions

7. MAINTENANCE:
   - Keep dependencies updated
   - Monitor crash reports
   - Implement proper logging
   - Document complex business logic

This comprehensive Swift iOS reference provides a solid foundation for building
modern iOS applications with SwiftUI, combining best practices with practical
implementation examples.
*/