//

//  MeterView.swift

//  USB Meter

//

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

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

//

// MARK: Parent frame https://stackoverflow.com/questions/56832865/how-to-access-parents-frame-in-swiftui

import SwiftUI

import CoreBluetooth

struct MeterView: View {

    @EnvironmentObject private var meter: Meter

    @State var dataGroupsViewVisibility: Bool = false

    private var myBounds: CGRect { UIScreen.main.bounds }

    private let actionDividerWidth: CGFloat = 1

    private let actionButtonMinWidth: CGFloat = 88

    private let actionButtonHeight: CGFloat = 108

            let landscape = isLandscape(size: proxy.size)

            Group {

                if landscape {

                    landscapeDeck(size: proxy.size)

                } else {

                    portraitContent

                }

            }

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

            .navigationBarHidden(landscape)

        }

        .background(meterBackground)

        .navigationBarTitle("Meter")

        .navigationBarItems(trailing: HStack (spacing: 6) {

            if meter.operationalState > .notPresent {

                RSSIView(RSSI: meter.btSerial.RSSI)

                    .frame(width: 18, height: 18)

                    .padding(.leading, 6)

                    .padding(.vertical)

            }

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

                Image(systemName: "info.circle.fill")

                    .padding(.vertical)

            }

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

                Image(systemName: "gearshape.fill")

                    .padding(.vertical)

            }

        })

    }

    private var portraitContent: some View {

                        .padding(18)

                        .meterCard(tint: meter.color, fillOpacity: 0.12, strokeOpacity: 0.20)

                        MeasurementChartView()

                            .environmentObject(meter.measurements)

                            .frame(minHeight: myBounds.height / 3.4)

                            .padding(16)

                            .meterCard(tint: meter.color, fillOpacity: 0.12, strokeOpacity: 0.20)

            }

    private func landscapeDeck(size: CGSize) -> some View {

        TabView {

            landscapeFace {

            if meter.operationalState == .dataIsAvailable {

                landscapeFace {

                    LiveView(compactLayout: true, availableSize: size)

                        .padding(16)

                }

                if meter.measurements.power.context.isValid {

                    landscapeFace {

                        MeasurementChartView()

                            .environmentObject(meter.measurements)

                            .frame(height: max(250, size.height - 44))

                            .padding(10)

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

                            .meterCard(tint: meter.color, fillOpacity: 0.12, strokeOpacity: 0.20)

                    }

                }

        .tabViewStyle(PageTabViewStyle(indexDisplayMode: .automatic))

    }

    private func landscapeFace<Content: View>(@ViewBuilder content: () -> Content) -> some View {

        content()

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

        .padding(.horizontal, 12)

        LinearGradient(

            colors: [

                meter.color.opacity(0.22),

                Color.secondary.opacity(0.08),

                Color.clear

            ],

            startPoint: .topLeading,

            endPoint: .bottomTrailing

        )

        .ignoresSafeArea()

    }

    private func isLandscape(size: CGSize) -> Bool {

        size.width > size.height

    }

                Spacer(minLength: 0)

            }

            connectionActionArea(compact: compact)

            if showsActions {

                VStack(spacing: compact ? 10 : 12) {

                    Rectangle()

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

                        .frame(height: 1)

                    actionGrid(compact: compact, embedded: true)

                }

            }

        .frame(maxWidth: .infinity, maxHeight: compact ? .infinity : nil, alignment: .topLeading)

    }

        HStack(alignment: .firstTextBaseline, spacing: 8) {

            Text(meter.name)

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

                .lineLimit(1)

                .minimumScaleFactor(0.8)

            Text(meter.deviceModelName)

                .font((compact ? Font.caption : .subheadline).weight(.semibold))

                .foregroundColor(.secondary)

                .lineLimit(1)

                .minimumScaleFactor(0.8)

        }

    }

        let currentActionHeight = compact ? CGFloat(86) : actionButtonHeight

        return GeometryReader { proxy in

                meterSheetButton(icon: "square.grid.2x2.fill", title: meter.dataGroupsTitle, tint: .teal, width: buttonWidth, height: currentActionHeight, compact: compact) {

                    dataGroupsViewVisibility.toggle()

                }

                .sheet(isPresented: $dataGroupsViewVisibility) {

                    DataGroupsView(visibility: $dataGroupsViewVisibility)

                        .environmentObject(meter)

                }

                    actionStripDivider(height: currentActionHeight)

                    meterSheetButton(icon: "gauge.with.dots.needle.50percent", title: "Charge Record", tint: .pink, width: buttonWidth, height: currentActionHeight, compact: compact) {

                        recordingViewVisibility.toggle()

                        RecordingView(visibility: $recordingViewVisibility)

                    }

                meterSheetButton(icon: "clock.arrow.circlepath", title: "App History", tint: .blue, width: buttonWidth, height: currentActionHeight, compact: compact) {

                    measurementsViewVisibility.toggle()

                }

                .sheet(isPresented: $measurementsViewVisibility) {

                    MeasurementsView(visibility: $measurementsViewVisibility)

                        .environmentObject(meter.measurements)

                }

            }

            .padding(actionStripPadding)

            .frame(width: stripWidth)

                Spacer(minLength: 0)

                    .meterCard(

                        tint: embedded ? meter.color : Color.secondary,

                        fillOpacity: embedded ? 0.08 : 0.10,

                        strokeOpacity: embedded ? 0.14 : 0.16,

                        cornerRadius: embedded ? 24 : 22

                    )

        }

    }

    private func connectionActionArea(compact: Bool = false) -> some View {

            if meter.operationalState == .notPresent {

                    Image(systemName: "exclamationmark.triangle.fill")

                        .foregroundColor(.orange)

                    Text("Not found at this time.")

                        .fontWeight(.semibold)

                    Spacer()

                }

                    }

                }) {

                            .frame(width: 30, height: 30)

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

                            .fontWeight(.semibold)

        }

    }

                    .frame(width: compact ? 34 : 40, height: compact ? 34 : 40)

                    .lineLimit(2)

                    .minimumScaleFactor(0.9)

        .buttonStyle(.plain)

    }

        meter.supportsRecordingView ? 3 : 2

    }

    private func actionButtonWidth(for availableWidth: CGFloat) -> CGFloat {

        let contentWidth = availableWidth - (actionStripPadding * 2) - dividerWidth

        let fittedWidth = floor(contentWidth / visibleActionButtonCount)

    }

        let dividerWidth = actionDividerWidth * max(visibleActionButtonCount - 1, 0)

        return (buttonWidth * visibleActionButtonCount) + dividerWidth + (actionStripPadding * 2)

    }

            .fill(Color.secondary.opacity(0.16))

    }

    private var statusBadge: some View {

        Text(statusText)

            .font(.caption.weight(.bold))

            .padding(.horizontal, 12)

            .padding(.vertical, 6)

            .meterCard(tint: statusColor, fillOpacity: 0.24, strokeOpacity: 0.30, cornerRadius: 999)

    private var connectActionTint: Color {

        Color(red: 0.20, green: 0.46, blue: 0.43)

    }

    private var disconnectActionTint: Color {

        Color(red: 0.66, green: 0.39, blue: 0.35)

    }

        switch meter.operationalState {

        case .notPresent:

            return "Missing"

        case .peripheralNotConnected:

            return "Ready"

        case .peripheralConnectionPending:

            return "Connecting"

        case .peripheralConnected:

            return "Linked"

        case .peripheralReady:

            return "Preparing"

        case .comunicating:

            return "Syncing"

        case .dataIsAvailable:

            return "Live"

        }

    }

    private var statusColor: Color {

        Meter.operationalColor(for: meter.operationalState)

private struct MeterInfoView: View {

    @EnvironmentObject private var meter: Meter

    var body: some View {

        ScrollView {

            VStack(spacing: 14) {

                MeterInfoCard(title: "Overview", tint: meter.color) {

                    MeterInfoRow(label: "Name", value: meter.name)

                    MeterInfoRow(label: "Working Voltage", value: meter.documentedWorkingVoltage)

                    MeterInfoRow(label: "Temperature Unit", value: meter.temperatureUnitDescription)

                }

                MeterInfoCard(title: "Identifiers", tint: .blue) {

                    MeterInfoRow(label: "MAC", value: meter.btSerial.macAddress.description)

                    if meter.modelNumber != 0 {

                }

                    if meter.reportsCurrentScreenIndex {

                        MeterInfoRow(label: "Current Screen", value: meter.currentScreenDescription)

                        Text("The active screen index is reported by the meter and mapped by the app to a known label.")

                            .font(.footnote)

                            .foregroundColor(.secondary)

                    } else {

                        MeterInfoRow(label: "Current Screen", value: "Not Reported")

                        Text("The current screen is not reported by the device payload, or we have not yet identified where and how the protocol announces it.")

                            .font(.footnote)

                            .foregroundColor(.secondary)

                    }

                }

                    MeterInfoCard(title: "Live Device Details", tint: .indigo) {

                        if !meter.firmwareVersion.isEmpty {

                            MeterInfoRow(label: "Firmware", value: meter.firmwareVersion)

                        }

                            MeterInfoRow(label: "Detected Charger", value: meter.chargerTypeDescription)

                        }

                            MeterInfoRow(label: "Serial", value: "\(meter.serialNumber)")

                        }

                        if meter.bootCount != 0 {

                            MeterInfoRow(label: "Boot Count", value: "\(meter.bootCount)")

                        }

                    }

                } else {

                    MeterInfoCard(title: "Live Device Details", tint: .secondary) {

                        Text("Connect to the meter to load firmware, serial, and boot details.")

                            .font(.footnote)

                            .foregroundColor(.secondary)

                    }

                }

            }

            .padding()

        }

        .background(

            LinearGradient(

                colors: [meter.color.opacity(0.14), Color.clear],

                startPoint: .topLeading,

                endPoint: .bottomTrailing

            )

            .ignoresSafeArea()

        )

}

private struct MeterInfoCard<Content: View>: View {

    let title: String

    let tint: Color

    @ViewBuilder var content: Content

    var body: some View {

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

            Text(title)

                .font(.headline)

            content

        }

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

        .padding(18)

        .meterCard(tint: tint, fillOpacity: 0.18, strokeOpacity: 0.24)

    }

}

private struct MeterInfoRow: View {

    let label: String

    let value: String

    var body: some View {

        HStack {

            Text(label)

            Spacer()

            Text(value)

                .foregroundColor(.secondary)

                .multilineTextAlignment(.trailing)

        }

        .font(.footnote)

    }

}