passepartout-apple/Passepartout/App/Views/OrganizerView+Profiles.swift

//
//  OrganizerView+Profiles.swift
//  Passepartout
//
//  Created by Davide De Rosa on 4/2/22.
//  Copyright (c) 2022 Davide De Rosa. All rights reserved.
//
//  https://github.com/passepartoutvpn
//
//  This file is part of Passepartout.
//
//  Passepartout is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  Passepartout is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with Passepartout.  If not, see <http://www.gnu.org/licenses/>.
//

import SwiftUI
import PassepartoutCore

extension OrganizerView {
    struct ProfilesList: View {
        @ObservedObject private var appManager: AppManager

        @ObservedObject private var profileManager: ProfileManager

        @ObservedObject private var providerManager: ProviderManager

        // just to observe changes in profiles eligibility
        @ObservedObject private var productManager: ProductManager
        
        @Binding private var alertType: AlertType?

        @State private var isFirstLaunch = true
        
        @State private var selectedProfileId: UUID?
        
        init(alertType: Binding<AlertType?>) {
            appManager = .shared
            profileManager = .shared
            providerManager = .shared
            productManager = .shared
            _alertType = alertType
        }

        var body: some View {
            debugChanges()
            return ReloadingContent(
                observing: profileManager.headers,
                equality: {
                    Set($0) == Set($1)
                }
            ) { headers in
                mainView(headers)
                if headers.isEmpty {
                    emptyView
                }
            }.onAppear(perform: performMigrationsIfNeeded)

            // detect deletion
            .onChange(of: profileManager.headers, perform: dismissSelectionIfDeleted)

            // from AddProfileView
            .onReceive(profileManager.didCreateProfile) {
                selectedProfileId = $0.id
            }
        }
        
        private func mainView(_ headers: [Profile.Header]) -> some View {
            List {
                Section {
                    ForEach(headers.sorted(), content: navigationLink(forHeader:))
                        .onDelete(perform: removeProfiles)
                }
            }
        }

        // FIXME: l10n
        private var emptyView: some View {
            VStack {
                Text("No profiles")
                    .themeInformativeText()
            }
        }

        private func navigationLink(forHeader header: Profile.Header) -> some View {
            NavigationLink(tag: header.id, selection: $selectedProfileId) {
                ProfileView(header: header)
            } label: {
                if profileManager.isActiveProfile(header.id) {
                    ActiveProfileHeaderRow(header: header)
                } else {
                    ProfileHeaderRow(header: header)
                }
            }.onAppear {
                preselectActiveProfile(header.id)
            }
        }
    }
}

extension OrganizerView.ProfilesList {
    struct ActiveProfileHeaderRow: View {
        @ObservedObject private var currentVPNState: VPNManager.ObservableState

        private let header: Profile.Header
        
        init(header: Profile.Header) {
            currentVPNState = .shared
            self.header = header
        }
        
        var body: some View {
            debugChanges()
            return ProfileHeaderRow(header: header)
                .withTrailingText(statusDescription)
        }

        private var statusDescription: String {
            return currentVPNState.localizedStatusDescription(
                withErrors: false,
                withDataCount: false
            )
        }
    }
}

extension OrganizerView.ProfilesList {
    private func preselectActiveProfile(_ id: UUID) {
        guard isFirstLaunch else {
            return
        }
        isFirstLaunch = false

        // do not push profile if:
        //
        // - an alert is active, as it would break navigation
        // - on iPad, as it's already shown
        //
        if alertType == nil,
           themeIdiom != .pad,
           id == profileManager.activeHeader?.id {

            selectedProfileId = id
        }
    }

    private func performMigrationsIfNeeded() {
        Task {
            await appManager.doMigrations(profileManager)
        }
    }
    
    private func removeProfiles(_ indexSet: IndexSet) {
        withAnimation {
            doRemoveProfiles(indexSet)
        }
    }

    private func doRemoveProfiles(_ indexSet: IndexSet) {
        let headers = profileManager.headers.sorted()
        var toDelete: [UUID] = []
        indexSet.forEach {
            toDelete.append(headers[$0].id)
        }

        // clear selection before removal to avoid triggering a bogus navigation push
        if let selectedProfileId = selectedProfileId, toDelete.contains(selectedProfileId) {
            self.selectedProfileId = nil
        }

        profileManager.removeProfiles(withIds: toDelete)
    }

    private func dismissSelectionIfDeleted(headers: [Profile.Header]) {
        if let selectedProfileId = selectedProfileId,
           !profileManager.isExistingProfile(withId: selectedProfileId) {

            self.selectedProfileId = nil
        }
    }
}