import SwiftUI

/// Uses same tab-based layout as MeterView but filtered to available operations.

    @Environment(\.dismiss) private var dismiss

    @State private var editorVisibility = false

    @State private var deleteConfirmationVisibility = false

            let landscape = proxy.size.width > proxy.size.height

            VStack(spacing: 0) {

                // Compact header matching online meters

                HStack(spacing: 12) {

                    Text(meterSummary.displayName.isEmpty ? "Meter" : meterSummary.displayName)

                        .font(.headline)

                        .lineLimit(1)

                    Spacer()

                    Button("Edit") {

                        editorVisibility = true

                    }

                    .font(.body.weight(.semibold))

                    Button(role: .destructive) {

                        deleteConfirmationVisibility = true

                    } label: {

                        Image(systemName: "trash")

                    }

                    .font(.body.weight(.semibold))

                }

                .padding(.horizontal, 16)

                .padding(.vertical, 10)

                .background(

                    Rectangle()

                        .fill(.ultraThinMaterial)

                        .ignoresSafeArea(edges: .top)

                )

                .overlay(alignment: .bottom) {

                    Rectangle()

                        .fill(Color.secondary.opacity(0.12))

                        .frame(height: 1)

                }

                // Content

                ScrollView {

                    VStack(spacing: 18) {

                        headerCard

                        statusCard

                        identifiersCard

                    }

                    .padding()

                }

                .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)

        }

        .background(

            LinearGradient(

                endPoint: .bottomTrailing

            )

            .ignoresSafeArea()

        )

            MeterEditorSheetView(existingMeterSummary: meterSummary)

                .environmentObject(appData)

        }

        .alert("Delete Meter?", isPresented: $deleteConfirmationVisibility) {

            Button("Delete", role: .destructive) {

                if appData.deleteMeter(macAddress: meterSummary.macAddress) {

                    dismiss()

                }

            }

            Button("Cancel", role: .cancel) {}

        } message: {

            Text("This removes the stored meter entry and its saved metadata from the sidebar until the meter is discovered again.")

        }

    private var headerCard: some View {

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

                .foregroundColor(.secondary)

                    .font(.caption2)

                    .foregroundColor(.secondary)

            }

        }

        .frame(maxWidth: .infinity, alignment: .leading)

        .padding(18)

    private var statusCard: some View {

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

                Text("Status")

                    .font(.headline)

                ContextInfoButton(

                    title: "Status",

            }

                Circle()

                Text("Offline")

                    .font(.caption.weight(.semibold))

                    .foregroundColor(.secondary)

            }

        }

        .frame(maxWidth: .infinity, alignment: .leading)

        .padding(18)

            if let advertisedName = meterSummary.advertisedName {

                infoRow(label: "Advertised as", value: advertisedName)

            }

        .frame(maxWidth: .infinity, alignment: .leading)

        .padding(18)

        .meterCard(tint: .secondary, fillOpacity: 0.12, strokeOpacity: 0.18, cornerRadius: 18)

    }

    private func infoRow(label: String, value: String) -> some View {

        HStack {

            Text(label)

            Spacer()

            Text(value)

                .foregroundColor(.secondary)

                .font(.caption)

        }

    }

}

struct MeterDetailView_Previews: PreviewProvider {

    static var previews: some View {

        MeterDetailView(

                displayName: "Desk Meter",

                modelSummary: "UM25C",

                advertisedName: "UM25C-123",

                lastSeen: Date(),

                lastConnected: Date().addingTimeInterval(-3600),

                meter: nil

            )

        )

}

struct MeterEditorSheetView: View {

    @EnvironmentObject private var appData: AppData

    @Environment(\.dismiss) private var dismiss

    let existingMeterSummary: AppData.MeterSummary?

    @State private var customName: String

    @State private var macAddress: String

    @State private var advertisedName: String

    @State private var selectedModel: Model

    init(existingMeterSummary: AppData.MeterSummary? = nil) {

        self.existingMeterSummary = existingMeterSummary

        _customName = State(initialValue: existingMeterSummary?.displayName ?? "")

        _macAddress = State(initialValue: existingMeterSummary?.macAddress ?? "")

        _advertisedName = State(initialValue: existingMeterSummary?.advertisedName ?? "")

        _selectedModel = State(initialValue: Self.model(for: existingMeterSummary?.modelSummary))

    }

    var body: some View {

        NavigationView {

            Form {

                    header: ContextInfoHeader(

                        title: "Identity",

                        message: "Use the real BLE MAC address format `AA:BB:CC:DD:EE:FF`. Saved meters remain visible in the sidebar even when they are currently offline."

                    )

                ) {

                    TextField("MAC Address", text: $macAddress)

                        .textInputAutocapitalization(.characters)

                        .disableAutocorrection(true)

                        .disabled(existingMeterSummary != nil)

                    Picker("Model", selection: $selectedModel) {

                        ForEach(Model.allCases, id: \.self) { model in

                            Text(model.canonicalName)

                                .tag(model)

                        }

                    }

                    TextField("Advertised name", text: $advertisedName)

                }

            }

            .navigationTitle(existingMeterSummary == nil ? "New Meter" : "Edit Meter")

            .navigationBarTitleDisplayMode(.inline)

            .toolbar {

                ToolbarItem(placement: .cancellationAction) {

                    Button("Cancel") {

                        dismiss()

                    }

                }

                ToolbarItem(placement: .confirmationAction) {

                    Button(existingMeterSummary == nil ? "Save" : "Update") {

                        let normalizedMAC = AppData.normalizedMACAddress(macAddress)

                        let didSave = appData.createKnownMeter(

                            macAddress: normalizedMAC,

                            customName: customName,

                            modelName: selectedModel.canonicalName,

                            advertisedName: advertisedName

                        )

                        if didSave {

                            dismiss()

                        }

                    }

                    .disabled(isSaveDisabled)

                }

            }

        }

        .navigationViewStyle(StackNavigationViewStyle())

    }

    private var isSaveDisabled: Bool {

        AppData.isValidMACAddress(AppData.normalizedMACAddress(macAddress)) == false

    }

    private static func model(for summary: String?) -> Model {

        if summary?.contains("UM34C") == true {

            return .UM34C

        }

        if summary?.contains("TC66C") == true {

            return .TC66C

        }

        return .UM25C

}