Meshtastic-Apple/Meshtastic/Views/Settings/UserConfig.swift

//
//  User.swift
//  Meshtastic Apple
//
//  Copyright (c) Garth Vander Houwen 6/27/22.
//
import CoreData
import MeshtasticProtobufs
import SwiftUI

struct UserConfig: View {

	@Environment(\.managedObjectContext) var context
	@EnvironmentObject var accessoryManager: AccessoryManager
	@Environment(\.dismiss) private var goBack

	var node: NodeInfoEntity?

	enum Field: Hashable {
		case frequencyOverride
	}

	@State private var isPresentingFactoryResetConfirm: Bool = false
	@State private var isPresentingSaveConfirm: Bool = false
	@State var hasChanges = false
	@State var shortName = ""
	@State var longName: String = ""
	@State var isUnmessagable: Bool = false
	@State var isLicensed = false
	@State var overrideDutyCycle = false
	@State var overrideFrequency: Float = 0.0
	@State var txPower = 0
	@FocusState var focusedField: Field?

	public var minimumVersion = "2.6.9"
	let floatFormatter: NumberFormatter = {
		let formatter = NumberFormatter()
		formatter.numberStyle = .decimal
		return formatter
	}()

	var body: some View {

		VStack {
			Form {
				Section(header: Text("User Details")) {

					VStack(alignment: .leading) {
						HStack {
							Label(isLicensed ? "Call Sign" : "Long Name", systemImage: "person.crop.rectangle.fill")

							TextField("Long Name", text: $longName)
								.onChange(of: longName) {
									var newValue = longName.withoutVariationSelectors
									var totalBytes = newValue.utf8.count
									// Only mess with the value if it is too big
									while totalBytes > (isLicensed ? 6 : 36) {
										newValue = String(newValue.dropLast())
										totalBytes = newValue.utf8.count
									}
									longName = newValue
									if longName.contains("📵") {
										isUnmessagable = true
									}
								}
						}
						.keyboardType(.default)
						.disableAutocorrection(true)
						if longName.isEmpty && isLicensed {
							Label("Call Sign must not be empty", systemImage: "exclamationmark.square")
								.foregroundColor(.red)
						}
						Text("\(String(isLicensed ? "Call Sign" : "Long Name")) can be up to \(isLicensed ? "8" : "36") bytes long.")
							.foregroundColor(.gray)
							.font(.callout)

					}
					VStack(alignment: .leading) {
						HStack {
							Label("Short Name", systemImage: "circlebadge.fill")
							TextField("Short Name", text: $shortName)
								.foregroundColor(.gray)
								.onChange(of: shortName) {
									let newValue = shortName.withoutVariationSelectors
									let totalBytes = newValue.utf8.count
									// Only mess with the value if it is too big
									if totalBytes > 4 {
										// If too long, drop the last thing entered
										shortName = String(shortName.dropLast())
									} else if shortName != newValue {
										// If not too long, make sure the stripped
										// variant is placed back in text field if necessary
										shortName = newValue
									}
								}
								.foregroundColor(.gray)
						}
						.keyboardType(.default)
						.disableAutocorrection(true)
						Text("The last 4 of the device MAC address will be appended to the short name to set the device's BLE Name.  Short name can be up to 4 bytes long.")
							.foregroundColor(.gray)
							.font(.callout)
						let supportedVersion = accessoryManager.checkIsVersionSupported(forVersion: minimumVersion)
						Toggle(isOn: $isUnmessagable) {
							Label("Unmessagable", systemImage: "iphone.slash")
							Text("Used to identify unmonitored or infrastructure nodes so that messaging is not avaliable to nodes that will never respond.")
								.font(.caption2)
						}
						.toggleStyle(SwitchToggleStyle(tint: .accentColor))
						.disabled(!supportedVersion)
					}
					// Only manage ham mode for the locally connected node
					if node?.num ?? 0 > 0 && node?.num ?? 0 == accessoryManager.activeDeviceNum ?? 0 {
						Toggle(isOn: $isLicensed) {
							Label("Licensed Operator", systemImage: "person.text.rectangle")
						}
						.toggleStyle(SwitchToggleStyle(tint: .accentColor))
						if isLicensed {

							Text("Onboarding for licensed operators requires firmware 2.0.20 or greater. Make sure to refer to your local regulations and contact the local amateur frequency coordinators with questions.")
								.font(.caption2)
							Text("What licensed operator mode does:\n* Sets the node name to your call sign \n* Broadcasts node info every 10 minutes \n* Overrides frequency, dutycycle and tx power \n* Disables encryption")
								.font(.caption2)

							HStack {
								Label("Frequency", systemImage: "waveform.path.ecg")
								Spacer()
								TextField("Frequency Override", value: $overrideFrequency, formatter: floatFormatter)
									.toolbar {
										ToolbarItemGroup(placement: .keyboard) {
											Button("Dismiss") {
												focusedField = nil
											}
											.font(.subheadline)
										}
									}
									.keyboardType(.decimalPad)
									.scrollDismissesKeyboard(.immediately)
									.focused($focusedField, equals: .frequencyOverride)
							}
							HStack {
								Image(systemName: "antenna.radiowaves.left.and.right")
									.foregroundColor(.accentColor)
								Stepper("\(txPower)db Transmit Power", value: $txPower, in: 1...30, step: 1)
									.padding(5)
							}
						}
					}
				}
			}
			.disabled(!accessoryManager.isConnected)
			HStack {
				Button {
					isPresentingSaveConfirm = true
				} label: {
					Label("Save", systemImage: "square.and.arrow.down")
				}
				.disabled(!accessoryManager.isConnected || !hasChanges)
				.buttonStyle(.bordered)
				.buttonBorderShape(.capsule)
				.controlSize(.large)
				.padding()
				.confirmationDialog(
					"Are you sure?",
					isPresented: $isPresentingSaveConfirm,
					titleVisibility: .visible
				) {
					Button("Save User Config to \(node?.user?.longName ?? "Unknown")?") {
						if longName.isEmpty && isLicensed {
							return
						}

						let connectedUser = getUser(id: accessoryManager.activeDeviceNum ?? -1, context: context)
						let connectedNode = getNodeInfo(id: accessoryManager.activeDeviceNum ?? -1, context: context)
						if node != nil && connectedNode != nil {

							if !isLicensed {
								var u = User()
								u.shortName = shortName
								u.longName = longName
								u.isUnmessagable = isUnmessagable

								Task {
									_ = try await accessoryManager.saveUser(config: u, fromUser: connectedUser, toUser: node!.user!)
									Task { @MainActor in
										hasChanges = false
										goBack()
									}
								}
							} else {
								var ham = HamParameters()
								ham.shortName = shortName
								// ham.isUnmessagable = isUnmessagable
								ham.callSign = longName
								ham.txPower = Int32(txPower)
								ham.frequency = overrideFrequency
								Task {
									_ = try await accessoryManager.saveLicensedUser(ham: ham, fromUser: connectedUser, toUser: node!.user!)
									Task { @MainActor in
										hasChanges = false
										goBack()
									}
								}
							}
						}
					}
				} message: {
					Text("After config values save the node will reboot.")
				}
			}
			Spacer()
		}
		.navigationTitle("User Config")
		.navigationBarItems(trailing:
								ZStack {
			ConnectedDevice(deviceConnected: accessoryManager.isConnected, name: accessoryManager.activeConnection?.device.shortName ?? "?")
		})
		.onAppear {
			self.shortName = node?.user?.shortName ?? ""
			self.longName = node?.user?.longName ?? ""
			self.isUnmessagable = node?.user?.unmessagable ?? false
			self.isLicensed = node?.user?.isLicensed ?? false
			self.txPower = Int(node?.loRaConfig?.txPower ?? 0)
			self.overrideFrequency = node?.loRaConfig?.overrideFrequency ?? 0.00
			self.hasChanges = false
		}
		.onChange(of: shortName) { oldShort, newShort in
			if oldShort != newShort && newShort != node?.user?.shortName ?? "Unknown" { hasChanges = true }
		}
		.onChange(of: longName) { oldLong, newLong in
			if oldLong != newLong && newLong != node?.user?.longName ?? "Unknown" { hasChanges = true }
		}
		.onChange(of: isUnmessagable) { oldIsUnmessagable, newIsUnmessagable in
			if oldIsUnmessagable != newIsUnmessagable && newIsUnmessagable != node?.user?.unmessagable ?? true { hasChanges = true }
		}
		.onChange(of: isLicensed) { _, newIsLicensed in
			if node != nil && node!.user != nil {
				if newIsLicensed != node?.user!.isLicensed {
					hasChanges = true
					if newIsLicensed {
						if node?.user?.longName?.count ?? 0 > 8 {
							longName = ""
						}
					}
				}
			}
		}
		.onChange(of: overrideFrequency) {
			if isLicensed { hasChanges = true }
		}
		.onChange(of: txPower) {
			if isLicensed { hasChanges = true }
		}
	}
}