//

//  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

        ScrollView {

                    actionGrid

                        .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)

                    ControlView()

                        .padding(16)

                        .meterCard(tint: .indigo, fillOpacity: 0.12, strokeOpacity: 0.20)

            }

            LinearGradient(

                colors: [

                    meter.color.opacity(0.22),

                    Color.secondary.opacity(0.08),

                    Color.clear

                ],

                startPoint: .topLeading,

                endPoint: .bottomTrailing

            )

            .ignoresSafeArea()

        )

                RSSIView(RSSI: meter.btSerial.RSSI)

                    .padding(.leading, 6)

            }

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

                    .padding(.vertical)

            }

            }

        })

    }

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

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

                    Text(meter.name)

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

                    Text(meter.deviceModelSummary)

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

                        .foregroundColor(.secondary)

                }

                Spacer()

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

                    Text(statusText)

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

                        .padding(.horizontal, 12)

                        .padding(.vertical, 6)

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

                    if meter.operationalState > .notPresent {

                        Text("RSSI \(meter.btSerial.RSSI)")

                            .font(.caption)

                            .foregroundColor(.secondary)

                    }

                }

            }

            connectionActionArea

        .padding(20)

        .meterCard(tint: meter.color, fillOpacity: 0.22, strokeOpacity: 0.24)

    }

    private var actionGrid: some View {

            let buttonWidth = actionButtonWidth(for: proxy.size.width)

            HStack {

                Spacer(minLength: 0)

                        dataGroupsViewVisibility.toggle()

                    }

                    .sheet(isPresented: $dataGroupsViewVisibility) {

                        DataGroupsView(visibility: $dataGroupsViewVisibility)

                            .environmentObject(meter)

                    }

                            recordingViewVisibility.toggle()

                        }

                        .sheet(isPresented: $recordingViewVisibility) {

                            RecordingView(visibility: $recordingViewVisibility)

                                .environmentObject(meter)

                        }

                    }

                        measurementsViewVisibility.toggle()

                    }

                    .sheet(isPresented: $measurementsViewVisibility) {

                        MeasurementsView(visibility: $measurementsViewVisibility)

                            .environmentObject(meter.measurements)

                    }

                }

                .frame(width: stripWidth)

                .meterCard(tint: Color.secondary, fillOpacity: 0.10, strokeOpacity: 0.16)

        }

            if meter.operationalState == .notPresent {

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

                        .foregroundColor(.orange)

                    Text("Not found at this time.")

                        .fontWeight(.semibold)

                    Spacer()

                }

                .padding(16)

                    }

                }) {

                            .frame(width: 30, height: 30)

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

                            .fontWeight(.semibold)

        }

    }

                    .frame(width: 40, height: 40)

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

                    .multilineTextAlignment(.center)

                    .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)

    }

    private var actionStripDivider: some View {

        Rectangle()

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

            .frame(width: actionDividerWidth, height: actionButtonHeight - 24)

    }

    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: "Displayed Model", value: meter.deviceModelSummary)

                    MeterInfoRow(label: "Advertised Model", value: meter.modelString)

                    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 {

                        MeterInfoRow(label: "Model Code", value: "\(meter.modelNumber)")

                    }

                }

                    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)

                        }

                        if meter.serialNumber != 0 {

                            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()

        )

        .navigationBarTitle("Meter Info")

}

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)

    }

}