//

//  ChargeSessionCompletionSheetView.swift

//  USB Meter

//

import SwiftUI

struct ChargeSessionCompletionSheetView: View {

        case full

        case skip

        case custom

        var id: String { rawValue }

        var label: String {

            switch self {

            case .full:   return "Full"

            case .skip:   return "Skip"

            case .custom: return "Other %"

            }

        }

    }

    @Environment(\.dismiss) private var dismiss

    let sessionID: UUID

    let title: String

    let confirmTitle: String

    let explanation: String

    let appliesTrim: Bool

    let trimStart: Date?

    let trimEnd: Date?

    @State private var batteryPercent = ""

    init(

        sessionID: UUID,

        title: String,

        confirmTitle: String,

        explanation: String,

        monitoringMeter: Meter? = nil,

        appliesTrim: Bool = false,

        trimStart: Date? = nil,

        trimEnd: Date? = nil

    ) {

        self.sessionID = sessionID

        self.title = title

        self.confirmTitle = confirmTitle

        self.explanation = explanation

        self.monitoringMeter = monitoringMeter

        self.appliesTrim = appliesTrim

        self.trimStart = trimStart

        self.trimEnd = trimEnd

    }

    var body: some View {

        NavigationView {

            Form {

                Section(

                    header: ContextInfoHeader(

                        title: "Final Checkpoint",

                        message: explanation

                    )

                ) {

                        ForEach(FinalCheckpoint.allCases) { mode in

                            Text(mode.label).tag(mode)

                        }

                    }

                    .pickerStyle(.segmented)

                    if finalCheckpoint == .custom {

                        TextField("Battery %", text: $batteryPercent)

                            .keyboardType(.decimalPad)

                    }

                Section {

                        Label("The selected trim window will be applied before the session is closed.", systemImage: "scissors")

                            .font(.footnote)

                            .foregroundColor(.blue)

                    }

                    if let saveFailureMessage {

                        Label(saveFailureMessage, systemImage: "exclamationmark.triangle.fill")

                            .foregroundColor(.red)

                        Label(saveDisabledReason, systemImage: "exclamationmark.triangle.fill")

                            .font(.footnote)

                            .foregroundColor(.red)

                    }

                            _ = appData.deleteChargeSession(sessionID: sessionID)

                            dismiss()

                        } label: {

                            Label("Discard Session", systemImage: "trash")

                        }

                            .font(.footnote)

                            .foregroundColor(.orange)

                            .font(.footnote)

                            .foregroundColor(.secondary)

                    }

                }

            }

            .navigationTitle(title)

            .navigationBarTitleDisplayMode(.inline)

            .toolbar {

                ToolbarItem(placement: .cancellationAction) {

                    Button("Cancel") {

                        dismiss()

                    }

                }

                ToolbarItem(placement: .confirmationAction) {

                    Button(confirmTitle) {

                            saveFailureMessage = saveDisabledReason

                            return

                        }

                        if appliesTrim {

                            _ = appData.setSessionTrim(

                                sessionID: sessionID,

                                start: trimStart,

                                end: trimEnd

                            )

                        }

                        if appData.stopChargeSession(

                            sessionID: sessionID,

                            finalBatteryPercent: resolvedFinalBatteryPercent,

                            from: monitoringMeter

                        ) {

                            saveFailureMessage = "The session could not be closed. Live readings were flushed, but the stored session did not accept the save yet. Try again in a moment."

                    }

                    .opacity(canSave ? 1 : 0.45)

            }

        }

        .navigationViewStyle(StackNavigationViewStyle())

            saveFailureMessage = nil

            if mode == .custom {

                prefillFinalCheckpointIfNeeded()

            } else {

                batteryPercent = ""

            }

        }

        .onChange(of: batteryPercent) { _ in

            saveFailureMessage = nil

        }

        appData.chargedDevices

            .flatMap(\.sessions)

            .first(where: { $0.id == sessionID })

    }

    private var canSave: Bool {

        guard let session else { return false }

        return session.hasSavableChargeData

            || displayedSessionEnergyWh(for: session) > 0

            || displayedSessionChargeAh(for: session) > 0

        if finalCheckpoint == .custom {

            let trimmed = batteryPercent.trimmingCharacters(in: .whitespacesAndNewlines)

            if trimmed.isEmpty {

                return "Enter the final battery percentage or choose Skip."

            }

            if parsedBatteryPercent == nil {

                return "Final battery percentage must be between 0 and 100."

            }

        }

        guard hasChargeDataToSave else {

            return "This session has no charging data to save. Discard it instead."

        return nil

        let normalized = batteryPercent

            .trimmingCharacters(in: .whitespacesAndNewlines)

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

        guard let value = Double(normalized), value >= 0, value <= 100 else { return nil }

        return value

    }

        switch finalCheckpoint {

        case .full:   return 100

        case .skip:   return nil

        case .custom: return parsedBatteryPercent

        }

    }

        guard let session else { return nil }

        if let endBatteryPercent = session.endBatteryPercent {

            return endBatteryPercent

        }

        if let latestCheckpoint = session.checkpoints.max(by: { $0.timestamp < $1.timestamp }) {

            return latestCheckpoint.batteryPercent

        }

        return session.targetBatteryPercent ?? session.completionContradictionPercent

    }

    private func prefillFinalCheckpointIfNeeded() {

        guard batteryPercent.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,

              let suggestedFinalBatteryPercent else {

            return

        }

        batteryPercent = suggestedFinalBatteryPercent.format(decimalDigits: 0)

    }

              let chargerID = session.chargerID,

              let charger = appData.chargedDeviceSummary(id: chargerID),

              charger.chargerIdleCurrentAmps == nil else {

            return nil

        }

        return "This charger has no idle-current measurement, so the final checkpoint will stop the session but will not learn a wireless stop threshold yet."

    }

    private func displayedSessionEnergyWh(for session: ChargeSessionSummary) -> Double {

        let storedEnergyWh = session.effectiveOrMeasuredEnergyWh

        guard session.isTrimmed == false else { return storedEnergyWh }

        guard session.status.isOpen else { return storedEnergyWh }

        guard let monitoringMeter else { return storedEnergyWh }

        guard session.meterMACAddress == monitoringMeter.btSerial.macAddress.description else { return storedEnergyWh }

        if let baselineEnergyWh = session.meterEnergyBaselineWh {

            return max(storedEnergyWh, max(monitoringMeter.recordedWH - baselineEnergyWh, 0))

        }

        return storedEnergyWh

    }

    private func displayedSessionChargeAh(for session: ChargeSessionSummary) -> Double {

        let storedChargeAh = session.measuredChargeAh

        guard session.isTrimmed == false else { return storedChargeAh }

        guard session.status.isOpen else { return storedChargeAh }

        guard let monitoringMeter else { return storedChargeAh }

        guard session.meterMACAddress == monitoringMeter.btSerial.macAddress.description else { return storedChargeAh }

        if let baselineChargeAh = session.meterChargeBaselineAh {

            return max(storedChargeAh, max(monitoringMeter.recordedAH - baselineChargeAh, 0))

        }

        return storedChargeAh

    }