//

//  ChargedDeviceEditorSheetView.swift

//  USB Meter

//

//  Created by Codex on 10/04/2026.

//

import SwiftUI

struct ChargedDeviceEditorSheetView: View {

    @EnvironmentObject private var appData: AppData

    @Environment(\.dismiss) private var dismiss

    let meterMACAddress: String?

    let chargedDevice: ChargedDeviceSummary?

    @State private var name: String

    @State private var lastAppliedTemplateID: String?

    @State private var supportsWirelessCharging: Bool

    @State private var wirelessChargingProfile: WirelessChargingProfile

    let standalone: Bool

    init(

        meterMACAddress: String?,

        standalone: Bool = true

        self.meterMACAddress = meterMACAddress

        self.chargedDevice = chargedDevice

        _notes = State(initialValue: chargedDevice?.notes ?? "")

            chargedDevice?.chargingStateAvailability ?? Self.suggestedChargingStateAvailability(for: initialDeviceClass)

        )

        let initialChargingSupport = initialDeviceClass.normalizedChargingSupport(

            supportsWiredCharging: chargedDevice?.supportsWiredCharging ?? true,

            supportsWirelessCharging: chargedDevice?.supportsWirelessCharging ?? true

        )

        let initialTemplateID = chargedDevice?.deviceTemplateID

        _lastAppliedTemplateID = State(initialValue: initialTemplateID)

        _chargingStateAvailability = State(initialValue: initialChargingStateAvailability)

        _supportsWiredCharging = State(initialValue: initialChargingSupport.wired)

        _supportsWirelessCharging = State(initialValue: initialChargingSupport.wireless)

    var body: some View {

            NavigationView { formContent }

                .navigationViewStyle(StackNavigationViewStyle())

        } else {

            formContent

        }

    }

        Form {

            identitySection

            templateSection

            deviceChargeBehaviourSection

            deviceChargingSupportSection

            deviceCompletionSection

            notesSection

        }

        .navigationTitle(editorTitle)

        .navigationBarTitleDisplayMode(.inline)

        .toolbar {

            ToolbarItem(placement: .cancellationAction) {

                Button("Cancel") {

                    dismiss()

            ToolbarItem(placement: .confirmationAction) {

                Button(saveButtonTitle) {

                    save()

        }

        .onChange(of: deviceClass) { newValue in

        }

        .onChange(of: selectedTemplateID) { newValue in

            applyTemplateSelection(

                previousTemplateID: lastAppliedTemplateID,

                newTemplateID: newValue

            )

            lastAppliedTemplateID = newValue

        .onAppear {

    }

        Section(header: Text("Identity")) {

                ForEach(ChargedDeviceClass.deviceCases) { deviceClass in

                    Label(deviceClass.title, systemImage: deviceClass.symbolName)

                        .tag(deviceClass)

            }

            if let chargedDevice {

                Text(chargedDevice.qrIdentifier)

                    .font(.caption.monospaced())

                    .foregroundColor(.secondary)

                    .textSelection(.enabled)

            }

        }

    }

        Section(

            header: ContextInfoHeader(

                title: "Template",

                message: "Templates load from a JSON catalog and provide the starting icon and charging profile for common devices and chargers."

            )

        ) {

            Picker("Template", selection: $selectedTemplateID) {

                Text("Custom")

                    .tag(String?.none)

                ForEach(groupedTemplates, id: \.group) { group in

                    Section(group.group) {

                        ForEach(group.templates) { template in

                            Text(template.name)

                                .tag(template.id as String?)

                        }

                    }

                }

            }

            if let selectedTemplate {

                ChargedDeviceTemplateLabelView(

                    template: selectedTemplate,

                    iconPointSize: 18

                )

                .font(.subheadline.weight(.semibold))

                Text(selectedTemplate.capabilitySummary)

                    .font(.caption)

                    .foregroundColor(.secondary)

            } else {

                Text("Choose a template when you want a predefined icon and a starting charging setup.")

                    .font(.caption)

                    .foregroundColor(.secondary)

            }

        }

    }

        Section(

            header: ContextInfoHeader(

                title: "Charge Behaviour",

                message: "Choose whether sessions for this device are recorded only while it is on, only while it is off, or explicitly in either state."

            )

        ) {

                VStack(alignment: .leading, spacing: 6) {

                    Label(enforcedChargingStateAvailability.title, systemImage: "lock.fill")

                        .font(.subheadline.weight(.semibold))

                    Text(enforcedChargingStateAvailability.description)

                        .font(.caption)

                        .foregroundColor(.secondary)

                }

            } else {

                Picker("Session Modes", selection: $chargingStateAvailability) {

                    ForEach(ChargingStateAvailability.allCases) { availability in

                        Text(availability.title)

                            .tag(availability)

                    }

            }

        }

    }

    private var deviceChargingSupportSection: some View {

        Section(

            header: ContextInfoHeader(

                title: "Charging Support",

                message: "Enable the charging methods this device actually supports. Wireless devices can also keep a dedicated profile so learning stays separate."

            )

        ) {

                VStack(alignment: .leading, spacing: 6) {

                    Label(

                        Self.chargingSupportDescription(

                            supportsWiredCharging: enforcedChargingSupport.wired,

                            supportsWirelessCharging: enforcedChargingSupport.wireless

                        ),

                        systemImage: "lock.fill"

                    )

                    .font(.subheadline.weight(.semibold))

                    Text("This device class is fixed so sessions cannot be recorded with an impossible charging transport.")

                        .font(.caption)

                        .foregroundColor(.secondary)

                }

            } else {

                Toggle("Supports wired charging", isOn: $supportsWiredCharging)

                Toggle("Supports wireless charging", isOn: $supportsWirelessCharging)

            }

                    ForEach(WirelessChargingProfile.allCases) { profile in

                        Text(profile.title)

                            .tag(profile)

                    }

                }

            }

            if supportedChargingModes.isEmpty {

                Text("Enable at least one charging method.")

                    .font(.footnote)

                    .foregroundColor(.secondary)

            }

        }

    }

    private var deviceCompletionSection: some View {

        Section(

            header: ContextInfoHeader(

                title: "Charge Completion",

                message: "Completion currents can be set per session type. Leave a value empty to keep learning that threshold automatically from sessions of the same type."

            )

        ) {

            if applicableSessionKinds.isEmpty {

                Text("Enable at least one charging method to configure stop currents.")

                    .font(.footnote)

                    .foregroundColor(.secondary)

            } else {

                ForEach(applicableSessionKinds) { sessionKind in

                    VStack(alignment: .leading, spacing: 6) {

                        TextField(

                        )

                        .keyboardType(.decimalPad)

                    }

                    .padding(.vertical, 2)

                }

            }

        }

    }

    private var notesSection: some View {

        Section(header: Text("Notes")) {

            TextField("Optional notes", text: $notes)

        }

    }

    private var saveButtonTitle: String {

        chargedDevice == nil ? "Save" : "Update"

    }

            && !hasInvalidCompletionCurrentEntry

    }

    private var groupedTemplates: [(group: String, templates: [ChargedDeviceTemplateDefinition])] {

        Dictionary(grouping: availableTemplates, by: \.group)

            .keys

            .sorted()

            .map { group in

                (

                    group: group,

                    templates: availableTemplates.filter { $0.group == group }

                )

            }

    }

    private var selectedTemplate: ChargedDeviceTemplateDefinition? {

        ChargedDeviceTemplateCatalog.shared.template(id: selectedTemplateID)

    }

        var modes: [ChargingTransportMode] = []

        if supportsWiredCharging {

            modes.append(.wired)

        }

        if supportsWirelessCharging {

            modes.append(.wireless)

        }

        return modes

    }

        supportedChargingModes.flatMap { chargingTransportMode in

            chargingStateAvailability.supportedModes.map { chargingStateMode in

                ChargeSessionKind(

                    chargingTransportMode: chargingTransportMode,

                    chargingStateMode: chargingStateMode

                )

            }

        }

    }

        supportsWirelessCharging

            && deviceClass != .watch

            && supportedChargingModes.count > 1

    }

        applicableSessionKinds.reduce(into: [ChargeSessionKind: Double]()) { result, sessionKind in

            guard let value = parsedOptionalCurrent(completionCurrentTexts[sessionKind] ?? "") else {

                return

            }

            result[sessionKind] = value

        }

    }

    private var hasInvalidCompletionCurrentEntry: Bool {

        applicableSessionKinds.contains { sessionKind in

            let text = completionCurrentTexts[sessionKind] ?? ""

            let normalized = text.trimmingCharacters(in: .whitespacesAndNewlines)

            return !normalized.isEmpty && parsedOptionalCurrent(text) == nil

        }

    }

    private func completionCurrentTextBinding(for sessionKind: ChargeSessionKind) -> Binding<String> {

        Binding(

            get: { completionCurrentTexts[sessionKind] ?? "" },

            set: { completionCurrentTexts[sessionKind] = $0 }

        )

    }

            didSave = appData.updateDevice(

                id: chargedDevice.id,

                name: name,

                deviceClass: deviceClass,

                templateID: selectedTemplateID,

                chargingStateAvailability: chargingStateAvailability,

                supportsWiredCharging: supportsWiredCharging,

                supportsWirelessCharging: supportsWirelessCharging,

                wirelessChargingProfile: wirelessChargingProfile,

                configuredCompletionCurrents: configuredCompletionCurrents,

                notes: notes

            )

                name: name,

                deviceClass: deviceClass,

                templateID: selectedTemplateID,

                chargingStateAvailability: chargingStateAvailability,

                supportsWiredCharging: supportsWiredCharging,

                supportsWirelessCharging: supportsWirelessCharging,

                wirelessChargingProfile: wirelessChargingProfile,

                configuredCompletionCurrents: configuredCompletionCurrents,

                notes: notes,

                meterMACAddress: meterMACAddress

            )

        if didSave {

            dismiss()

        }

    }

        previousTemplateID: String?,

        newTemplateID: String?

    ) {

        guard let newTemplate = ChargedDeviceTemplateCatalog.shared.template(id: newTemplateID) else {

        }

        let trimmedName = name.trimmingCharacters(in: .whitespacesAndNewlines)

        if trimmedName.isEmpty || trimmedName == previousTemplate?.name {

            name = newTemplate.name

        }

        chargingStateAvailability = newTemplate.deviceClass.normalizedChargingStateAvailability(

            newTemplate.chargingStateAvailability

        )

        let normalizedChargingSupport = newTemplate.deviceClass.normalizedChargingSupport(

            supportsWiredCharging: newTemplate.supportsWiredCharging,

            supportsWirelessCharging: newTemplate.supportsWirelessCharging

        )

        supportsWiredCharging = normalizedChargingSupport.wired

        supportsWirelessCharging = normalizedChargingSupport.wireless

        wirelessChargingProfile = newTemplate.wirelessChargingProfile

    }

    private func applyDeviceClassRules(for deviceClass: ChargedDeviceClass) {

        if let selectedTemplate {

            chargingStateAvailability = deviceClass.normalizedChargingStateAvailability(

                selectedTemplate.chargingStateAvailability

            )

            let normalizedChargingSupport = deviceClass.normalizedChargingSupport(

                supportsWiredCharging: selectedTemplate.supportsWiredCharging,

                supportsWirelessCharging: selectedTemplate.supportsWirelessCharging

            )

            supportsWiredCharging = normalizedChargingSupport.wired

            supportsWirelessCharging = normalizedChargingSupport.wireless

            wirelessChargingProfile = selectedTemplate.wirelessChargingProfile

            return

        }

        if let enforcedChargingStateAvailability = deviceClass.enforcedChargingStateAvailability {

            chargingStateAvailability = enforcedChargingStateAvailability

        } else if chargedDevice == nil {

            chargingStateAvailability = Self.suggestedChargingStateAvailability(for: deviceClass)

        }

        if let enforcedChargingSupport = deviceClass.enforcedChargingSupport {

            supportsWiredCharging = enforcedChargingSupport.wired

            supportsWirelessCharging = enforcedChargingSupport.wireless

        } else if chargedDevice == nil {

            switch deviceClass {

            case .iphone:

                supportsWiredCharging = true

                supportsWirelessCharging = true

            case .watch:

                supportsWiredCharging = false

                supportsWirelessCharging = true

            case .powerbank:

                supportsWiredCharging = true

                supportsWirelessCharging = false

            case .charger:

                supportsWiredCharging = false

                supportsWirelessCharging = true

            case .other:

                supportsWiredCharging = true

                supportsWirelessCharging = false

            }

    }

    private func parsedOptionalCurrent(_ text: String) -> Double? {

        let normalized = text

            .trimmingCharacters(in: .whitespacesAndNewlines)

            .replacingOccurrences(of: ",", with: ".")

        guard !normalized.isEmpty else {

            return nil

        }

            return nil

        }

        return value

    }

        let showsTransport = supportedChargingModes.count > 1

        let showsState = chargingStateAvailability.supportedModes.count > 1

        switch (showsTransport, showsState) {

        case (true, true):

            return "\(sessionKind.shortTitle) completion current (A)"

        case (true, false):

            return "\(sessionKind.chargingTransportMode.title) completion current (A)"

        case (false, true):

            return "\(sessionKind.chargingStateMode.title) completion current (A)"

        case (false, false):

            return "Stop current (A)"

        }

    }

        guard let chargedDevice else {

            return [:]

        }

        return ChargeSessionKind.allCases.reduce(into: [ChargeSessionKind: String]()) { result, sessionKind in

            result[sessionKind] = optionalCurrentText(

                chargedDevice.configuredCompletionCurrentAmps(for: sessionKind)

            )

        }

    private static func optionalCurrentText(_ value: Double?) -> String {

        guard let value else {

            return ""

        }

        return value.format(decimalDigits: 2)

    }

        supportsWiredCharging: Bool,

        supportsWirelessCharging: Bool

    ) -> String {

        switch (supportsWiredCharging, supportsWirelessCharging) {

        case (true, true):

            return "Supports wired and wireless charging"

        case (true, false):

            return "Supports wired charging only"

        case (false, true):

            return "Supports wireless charging only"

        case (false, false):

            return "No charging method configured"

        }

    }

        switch deviceClass {

        case .iphone:

            return .onOrOff

        case .watch:

            return .onOnly

        case .powerbank:

            return .offOnly

    }