//

//  ContentView.swift

//  USB Meter

//

//  Created by Bogdan Timofte on 01/03/2020.

//  Copyright © 2020 Bogdan Timofte. All rights reserved.

//

//MARK: Bluetooth Icon: https://upload.wikimedia.org/wikipedia/commons/d/da/Bluetooth.svg

import SwiftUI

struct ContentView: View {

        case bluetoothPermission

        var tint: Color {

            switch self {

            case .bluetoothPermission:

                return .orange

                return .indigo

                return .yellow

            }

        }

        var symbol: String {

            switch self {

            case .bluetoothPermission:

                return "bolt.horizontal.circle.fill"

                return "icloud.slash.fill"

                return "magnifyingglass.circle.fill"

            }

        }

        var badgeTitle: String {

            switch self {

            case .bluetoothPermission:

                return "Required"

                return "Sync Off"

                return "Suggested"

            }

        }

    }

    @State private var dismissedAutoHelpReason: HelpAutoReason?

    @State private var now = Date()

    private let helpRefreshTimer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()

    private let noDevicesHelpDelay: TimeInterval = 12

        NavigationView {

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

                    headerCard

                    helpSection

                    devicesSection

                LinearGradient(

                    colors: [

                        appData.bluetoothManager.managerState.color.opacity(0.18),

                        Color.clear

                    ],

                    startPoint: .topLeading,

                    endPoint: .bottomTrailing

                )

                .ignoresSafeArea()

            )

        }

            appData.bluetoothManager.start()

        }

        .onReceive(helpRefreshTimer) { currentDate in

            now = currentDate

        }

        .onChange(of: activeHelpAutoReason) { newReason in

            if newReason == nil {

                dismissedAutoHelpReason = nil

            }

    private var headerCard: some View {

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

            Text("USB Meters")

                .font(.system(.title2, design: .rounded).weight(.bold))

            Text("Browse nearby supported meters and jump into live diagnostics, charge records, and device controls.")

                .font(.footnote)

                .foregroundColor(.secondary)

            HStack {

                Label("Bluetooth", systemImage: "bolt.horizontal.circle.fill")

                    .font(.footnote.weight(.semibold))

                    .foregroundColor(appData.bluetoothManager.managerState.color)

                Spacer()

                Text(bluetoothStatusText)

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

                    .foregroundColor(.secondary)

            }

        }

        .padding(18)

        .meterCard(tint: appData.bluetoothManager.managerState.color, fillOpacity: 0.22, strokeOpacity: 0.26)

    }

    private var helpSection: some View {

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

                HStack(spacing: 14) {

                    Image(systemName: helpSectionSymbol)

                        .font(.system(size: 18, weight: .semibold))

                        .foregroundColor(helpSectionTint)

                        .frame(width: 42, height: 42)

                        .background(Circle().fill(helpSectionTint.opacity(0.18)))

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

                        Text("Help")

                            .font(.headline)

                        Text(helpSectionSummary)

                            .font(.caption)

                            .foregroundColor(.secondary)

                    }

                    Spacer()

                    if let activeHelpAutoReason {

                        Text(activeHelpAutoReason.badgeTitle)

                            .font(.caption2.weight(.bold))

                            .foregroundColor(activeHelpAutoReason.tint)

                            .padding(.horizontal, 10)

                            .padding(.vertical, 6)

                            .background(

                                Capsule(style: .continuous)

                                    .fill(activeHelpAutoReason.tint.opacity(0.12))

                            )

                            .overlay(

                                Capsule(style: .continuous)

                                    .stroke(activeHelpAutoReason.tint.opacity(0.22), lineWidth: 1)

                            )

                    }

                    Image(systemName: helpIsExpanded ? "chevron.up" : "chevron.down")

                        .font(.footnote.weight(.bold))

                        .foregroundColor(.secondary)

                }

                .padding(14)

                .meterCard(tint: helpSectionTint, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 18)

            .buttonStyle(.plain)

                if let activeHelpAutoReason {

                    helpNoticeCard(for: activeHelpAutoReason)

                }

                    Button(action: openSettings) {

                        sidebarLinkCard(

                            title: "Open Settings",

                            subtitle: "Check Apple ID, iCloud Drive, and any restrictions affecting Cloud sync.",

                            symbol: "gearshape.fill",

                            tint: .indigo

                        )

                    }

                    .buttonStyle(.plain)

                }

                    sidebarLinkCard(

                        title: "Bluetooth",

                        subtitle: "Permissions, adapter state, and connection tips.",

                        symbol: "bolt.horizontal.circle.fill",

                        tint: appData.bluetoothManager.managerState.color

                    )

                }

                .buttonStyle(.plain)

                NavigationLink(destination: DeviceHelpView()) {

                    sidebarLinkCard(

                        title: "Device",

                        subtitle: "Quick checks when a meter is not responding as expected.",

                        symbol: "questionmark.circle.fill",

                        tint: .orange

                    )

                }

                .buttonStyle(.plain)

        }

    private var devicesSection: some View {

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

            HStack {

                Spacer()

                    .padding(.horizontal, 10)

                    .padding(.vertical, 6)

                    .meterCard(tint: .blue, fillOpacity: 0.18, strokeOpacity: 0.24, cornerRadius: 999)

            }

                    .foregroundColor(.secondary)

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

                    .padding(18)

                        tint: isWaitingForFirstDiscovery ? .blue : .secondary,

                        fillOpacity: 0.14,

                        strokeOpacity: 0.20

                    )

                    if let meter = knownMeter.meter {

                        NavigationLink(destination: MeterView().environmentObject(meter)) {

                            MeterRowView()

                                .environmentObject(meter)

                        }

                        .buttonStyle(.plain)

                    } else {

                        knownMeterCard(for: knownMeter)

                }

            }

        }

    }

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

            Text("Debug")

                .font(.headline)

            debugLink

        }

    }

        NavigationLink(destination: MeterMappingDebugView()) {

            sidebarLinkCard(

                subtitle: "Inspect meter name sync data and iCloud KVS visibility as seen by this device.",

                tint: .purple

            )

        }

        .buttonStyle(.plain)

    }

        switch appData.bluetoothManager.managerState {

        case .poweredOff:

            return "Off"

        case .poweredOn:

            return "On"

        case .resetting:

            return "Resetting"

        case .unauthorized:

            return "Unauthorized"

        case .unknown:

            return "Unknown"

        case .unsupported:

            return "Unsupported"

        @unknown default:

            return "Other"

        }

    }

        isHelpExpanded || shouldAutoExpandHelp

    }

    private var shouldAutoExpandHelp: Bool {

        guard let activeHelpAutoReason else {

            return false

        }

        return dismissedAutoHelpReason != activeHelpAutoReason

    }

    private var activeHelpAutoReason: HelpAutoReason? {

        if appData.bluetoothManager.managerState == .unauthorized {

            return .bluetoothPermission

        }

            return .cloudSyncUnavailable

        }

            return .noDevicesDetected

        }

        return nil

    }

        switch appData.cloudAvailability {

        case .noAccount, .error:

            return true

        case .unknown, .available:

            return false

        }

    }

        guard appData.bluetoothManager.managerState == .poweredOn else {

            return false

        }

        guard appData.meters.isEmpty else {

            return false

        }

        guard let scanStartedAt = appData.bluetoothManager.scanStartedAt else {

            return false

        }

        return now.timeIntervalSince(scanStartedAt) >= noDevicesHelpDelay

    }

    private var isWaitingForFirstDiscovery: Bool {

        guard appData.bluetoothManager.managerState == .poweredOn else {

            return false

        }

        guard appData.meters.isEmpty else {

            return false

        }

        guard let scanStartedAt = appData.bluetoothManager.scanStartedAt else {

            return false

        }

        return now.timeIntervalSince(scanStartedAt) < noDevicesHelpDelay

    }

    private var devicesEmptyStateText: String {

        if isWaitingForFirstDiscovery {

            return "Scanning for nearby supported meters..."

        }

    private var helpSectionTint: Color {

        activeHelpAutoReason?.tint ?? .secondary

    }

    private var helpSectionSymbol: String {

        activeHelpAutoReason?.symbol ?? "questionmark.circle.fill"

    }

    private var helpSectionSummary: String {

        switch activeHelpAutoReason {

        case .bluetoothPermission:

            return "Bluetooth permission is needed before scanning can begin."

            return appData.cloudAvailability.helpMessage

            return "No supported devices were found after \(Int(noDevicesHelpDelay)) seconds."

        case nil:

            return "Connection tips and quick checks when discovery needs help."

        }

    }

    private func toggleHelpSection() {

        withAnimation(.easeInOut(duration: 0.22)) {

            if shouldAutoExpandHelp {

                dismissedAutoHelpReason = activeHelpAutoReason

                isHelpExpanded = false

            } else {

                isHelpExpanded.toggle()

            }

        }

    }

        guard let settingsURL = URL(string: UIApplication.openSettingsURLString) else {

            return

        }

        UIApplication.shared.open(settingsURL, options: [:], completionHandler: nil)

    }

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

            Text(helpNoticeTitle(for: reason))

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

            Text(helpNoticeDetail(for: reason))

                .font(.caption)

                .foregroundColor(.secondary)

        }

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

        .padding(14)

        .meterCard(tint: reason.tint, fillOpacity: 0.14, strokeOpacity: 0.20, cornerRadius: 18)

    }

    private func helpNoticeTitle(for reason: HelpAutoReason) -> String {

        switch reason {

        case .bluetoothPermission:

            return "Bluetooth access needs attention"

            return appData.cloudAvailability.helpTitle

            return "No supported meters found yet"

        }

    }

    private func helpNoticeDetail(for reason: HelpAutoReason) -> String {

        switch reason {

        case .bluetoothPermission:

            return "Open Bluetooth help to review the permission state and jump into Settings if access is blocked."

            return appData.cloudAvailability.helpMessage

            return "Open Device help for quick checks like meter power, Bluetooth availability on the meter, or an existing connection to another phone."

        }

    }

        title: String,

        subtitle: String,

        symbol: String,

        tint: Color

    ) -> some View {

        HStack(spacing: 14) {

            Image(systemName: symbol)

                .font(.system(size: 18, weight: .semibold))

                .foregroundColor(tint)

                .frame(width: 42, height: 42)

                .background(Circle().fill(tint.opacity(0.18)))

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

                Text(title)

                    .font(.headline)

                Text(subtitle)

                    .font(.caption)

                    .foregroundColor(.secondary)

            }

            Spacer()

            Image(systemName: "chevron.right")

                .font(.footnote.weight(.bold))

                .foregroundColor(.secondary)

        }

        .padding(14)

        .meterCard(tint: tint, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 18)

    }

    private func knownMeterCard(for knownMeter: AppData.KnownMeterSummary) -> some View {

        HStack(spacing: 14) {

            Image(systemName: "sensor.tag.radiowaves.forward.fill")

                .font(.system(size: 18, weight: .semibold))

                .foregroundColor(knownMeterTint(for: knownMeter))

                .frame(width: 42, height: 42)

                .background(

                    Circle()

                        .fill(knownMeterTint(for: knownMeter).opacity(0.18))

                )

                .overlay(alignment: .bottomTrailing) {

                    Circle()

                        .fill(Color.red)

                        .frame(width: 12, height: 12)

                        .overlay(

                            Circle()

                                .stroke(Color(uiColor: .systemBackground), lineWidth: 2)

                        )

                }

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

                Text(knownMeter.displayName)

                    .font(.headline)

                Text(knownMeter.modelSummary)

                    .font(.caption)

                    .foregroundColor(.secondary)

                if let advertisedName = knownMeter.advertisedName, advertisedName != knownMeter.modelSummary {

                    Text("Advertised as \(advertisedName)")

                        .font(.caption2)

                        .foregroundColor(.secondary)

                }

            }

            Spacer()

            VStack(alignment: .trailing, spacing: 4) {

                HStack(spacing: 6) {

                    Circle()

                        .fill(Color.red)

                        .frame(width: 8, height: 8)

                    Text("Missing")

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

                        .foregroundColor(.secondary)

                }

                .padding(.horizontal, 10)

                .padding(.vertical, 6)

                .background(

                    Capsule(style: .continuous)

                        .fill(Color.red.opacity(0.12))

                )

                .overlay(

                    Capsule(style: .continuous)

                        .stroke(Color.red.opacity(0.22), lineWidth: 1)

                )

                Text(knownMeter.macAddress)

                    .font(.caption2)

                    .foregroundColor(.secondary)

                if let lastSeen = knownMeter.lastSeen {

                    Text("Seen \(lastSeen.format(as: "yyyy-MM-dd HH:mm"))")

                        .font(.caption2)

                        .foregroundColor(.secondary)

                }

            }

        }

        .padding(14)

        .meterCard(

            tint: knownMeterTint(for: knownMeter),

            fillOpacity: 0.16,

            strokeOpacity: 0.22,

            cornerRadius: 18

        )

    }

    private func knownMeterTint(for knownMeter: AppData.KnownMeterSummary) -> Color {

        switch knownMeter.modelSummary {

        case "UM25C":

            return .blue

        case "UM34C":

            return .yellow

        case "TC66C":

            return Model.TC66C.color

        default:

            return .secondary

        }

    }