space-ios/iOSClient/Diagnostics/NCCapabilitiesView.swift

//
//  NCCapabilitiesView.swift
//  Nextcloud
//
//  Created by Marino Faggiana on 19/05/23.
//  Copyright © 2023 Marino Faggiana. All rights reserved.
//

import SwiftUI
import NextcloudKit

@objc class NCHostingCapabilitiesView: NSObject {

    @objc func makeShipDetailsUI() -> UIViewController {

        let capabilitiesStatus = NCCapabilitiesStatus()
        let view = NCCapabilitiesView(capabilitiesStatus: capabilitiesStatus)
        let vc = UIHostingController(rootView: view)
        vc.title = NSLocalizedString("_capabilities_", comment: "")
        return vc
    }
}

class NCCapabilitiesStatus: ObservableObject {

    struct Capability: Identifiable, Hashable {
        let id = UUID()
        let text: String
        let image: UIImage
        let available: Bool
    }

    @Published var capabililies: [Capability] = []
    @Published var json = "Lorem ipsum dolor sit amet. Ea voluptas aperiam aut inventore saepe in tenetur modi. Cum sint tempore sed maiores quos aut quaerat deleniti./nQui beatae quia qui repellat sunt in Quis libero aut quidem porro non explicabo tenetur et natus doloribus non voluptatum consequatur."

    init(preview: Bool = false) {

        if preview {
            capabililies = [Capability(text: "File sharing", image: UIImage(named: "share")!.resizeImage(size: CGSize(width: 25, height: 25))!, available: true),
                            Capability(text: "Externa site", image: UIImage(systemName: "network")!, available: false)
            ]
        } else {
            guard let account = NCManageDatabase.shared.getActiveAccount()?.account else { return }
            getCapabilities(account: account)
            updateCapabilities(account: account)
        }
    }

    func getCapabilities(account: String) {

        NextcloudKit.shared.getCapabilities { account, data, error in
            if error == .success && data != nil {
                NCManageDatabase.shared.addCapabilitiesJSon(data!, account: account)
                let serverVersionMajor = NCManageDatabase.shared.getCapabilitiesServerInt(account: account, elements: NCElementsJSON.shared.capabilitiesVersionMajor)
                if serverVersionMajor >= NCGlobal.shared.nextcloudVersion18 {
                    NextcloudKit.shared.NCTextObtainEditorDetails { account, editors, creators, _, error in
                        if error == .success {
                            NCManageDatabase.shared.addDirectEditing(account: account, editors: editors, creators: creators)
                            self.updateCapabilities(account: account)
                        }
                    }
                } else {
                    self.updateCapabilities(account: account)
                }
            } else {
                self.updateCapabilities(account: account)
            }
        }
    }

    func updateCapabilities(account: String) {

        var available: Bool = false
        capabililies.removeAll()
        self.json = ""

        // File Sharing
        available = NCManageDatabase.shared.getCapabilitiesServerBool(account: account, elements: NCElementsJSON.shared.capabilitiesFileSharingApiEnabled, exists: false)
        capabililies.append(Capability(text: "File sharing", image: UIImage(named: "share")!.resizeImage(size: CGSize(width: 25, height: 25))!, available: available))

        // ExternalSites
        available = NCManageDatabase.shared.getCapabilitiesServerBool(account: account, elements: NCElementsJSON.shared.capabilitiesExternalSitesExists, exists: true)
        capabililies.append(Capability(text: "External site", image: UIImage(systemName: "network")!, available: available))

        // E2EE
        available = NCManageDatabase.shared.getCapabilitiesServerBool(account: account, elements: NCElementsJSON.shared.capabilitiesE2EEEnabled, exists: false)
        capabililies.append(Capability(text: "End-to-End Encryption", image: UIImage(systemName: "lock")!, available: available))

        if NCManageDatabase.shared.getCapabilitiesServerArray(account: account, elements: NCElementsJSON.shared.capabilitiesActivity) == nil {
            available = false
        } else {
            available = true
        }
        capabililies.append(Capability(text: "Activity", image: UIImage(systemName: "bolt")!, available: available))

        if NCManageDatabase.shared.getCapabilitiesServerArray(account: account, elements: NCElementsJSON.shared.capabilitiesNotification) == nil {
            available = false
        } else {
            available = true
        }
        capabililies.append(Capability(text: "Notification", image: UIImage(systemName: "bell")!, available: available))

        available = NCManageDatabase.shared.getCapabilitiesServerBool(account: account, elements: NCElementsJSON.shared.capabilitiesFilesUndelete, exists: false)
        capabililies.append(Capability(text: "Deleted files", image: UIImage(systemName: "trash")!, available: available))

        var textEditor = false
        var onlyofficeEditors = false
        if let editors = NCManageDatabase.shared.getDirectEditingEditors(account: account) {
            for editor in editors {
                if editor.editor == NCGlobal.shared.editorText {
                    textEditor = true
                } else if editor.editor == NCGlobal.shared.editorOnlyoffice {
                    onlyofficeEditors = true
                }
            }
        }
        capabililies.append(Capability(text: "Text", image: UIImage(named: "text")!.resizeImage(size: CGSize(width: 25, height: 25))!, available: textEditor))
        capabililies.append(Capability(text: "ONLYOFFICE", image: UIImage(named: "onlyoffice")!.resizeImage(size: CGSize(width: 25, height: 25))!, available: onlyofficeEditors))

        if NCManageDatabase.shared.getCapabilitiesServerArray(account: account, elements: NCElementsJSON.shared.capabilitiesRichdocumentsMimetypes) == nil {
            available = false
        } else {
            available = true
        }
        capabililies.append(Capability(text: "Collabora", image: UIImage(named: "collabora")!.resizeImage(size: CGSize(width: 25, height: 25))!, available: available))

        available = NCManageDatabase.shared.getCapabilitiesServerBool(account: account, elements: NCElementsJSON.shared.capabilitiesUserStatusEnabled, exists: false)
        capabililies.append(Capability(text: "User Status", image: UIImage(systemName: "moon")!, available: available))

        available = NCManageDatabase.shared.getCapabilitiesServerBool(account: account, elements: NCElementsJSON.shared.capabilitiesFilesComments, exists: false)
        capabililies.append(Capability(text: "Comments", image: UIImage(systemName: "ellipsis.bubble")!, available: available))

        let hasLockCapability = NCManageDatabase.shared.getCapabilitiesServerInt(account: account, elements: NCElementsJSON.shared.capabilitiesFilesLockVersion) >= 1
        if hasLockCapability {
            available = false
        } else {
            available = true
        }
        capabililies.append(Capability(text: "Lock file", image: UIImage(systemName: "lock")!, available: available))

        available = NCManageDatabase.shared.getCapabilitiesServerBool(account: account, elements: NCElementsJSON.shared.capabilitiesGroupfoldersEnabled, exists: false)
        capabililies.append(Capability(text: "Group folders", image: UIImage(systemName: "person.2")!, available: available))

        if let json = NCManageDatabase.shared.getCapabilities(account: account) {
            self.json = json
        }
    }
}

struct NCCapabilitiesView: View {

    @ObservedObject var capabilitiesStatus: NCCapabilitiesStatus

    init(capabilitiesStatus: NCCapabilitiesStatus) {
        self.capabilitiesStatus = capabilitiesStatus
    }

    var body: some View {
        VStack {
            List {
                Section {
                    ForEach(capabilitiesStatus.capabililies, id: \.id) { capability in
                        HStack {
                            Capability(text: capability.text, image: Image(uiImage: capability.image))
                            CapabilityAvailable(available: capability.available)
                        }
                    }
                }
                Section {
                    TextEditor(text: .constant(capabilitiesStatus.json))
                        .font(.system(size: 12))
                        .frame(maxWidth: .infinity, maxHeight: .infinity)
                }
            }
        }
        .frame(maxWidth: .infinity, alignment: .top)
    }
}

struct Capability: View {

    @State var text: String = ""
    @State var image: Image

    var body: some View {
        Label {
            Text(text)
                .font(.system(size: 15))
                .foregroundColor(Color(UIColor.systemGray))
        } icon: {
            image
                .renderingMode(.template)
                .foregroundColor(Color(UIColor.systemGray))
        }
        .frame(maxWidth: .infinity, alignment: .leading)
    }
}

struct CapabilityAvailable: View {

    @State var available: Bool

    var body: some View {
        if available {
            Image(systemName: "checkmark.circle.fill")
                .foregroundColor(.green)
        } else {
            Image(systemName: "multiply.circle.fill")
                .foregroundColor(.red)
        }
    }
}

struct NCCapabilitiesView_Previews: PreviewProvider {
    static var previews: some View {
        NCCapabilitiesView(capabilitiesStatus: NCCapabilitiesStatus(preview: true))
    }
}