Trio/Trio/Sources/Modules/Home/View/Chart/ChartElements/GlucoseChartView.swift

import Charts
import Foundation
import SwiftUI

struct GlucoseChartView: ChartContent {
    let glucoseData: [GlucoseStored]
    let units: GlucoseUnits
    let highGlucose: Decimal
    let lowGlucose: Decimal
    let currentGlucoseTarget: Decimal
    let isSmoothingEnabled: Bool
    let glucoseColorScheme: GlucoseColorScheme

    var body: some ChartContent {
        drawGlucoseChart()
    }

    /// Dynamic point color for a CGM reading. Manual readings render red and skip this.
    private func pointColor(for item: GlucoseStored) -> Color {
        // TODO: workaround for now: set low value to 55, to have dynamic color shades between 55 and user-set low (approx. 70); same for high glucose
        let hardCodedLow = Decimal(55)
        let hardCodedHigh = Decimal(220)
        let isDynamicColorScheme = glucoseColorScheme == .dynamicColor

        return Trio.getDynamicGlucoseColor(
            glucoseValue: Decimal(item.glucose),
            highGlucoseColorValue: isDynamicColorScheme ? hardCodedHigh : highGlucose,
            lowGlucoseColorValue: isDynamicColorScheme ? hardCodedLow : lowGlucose,
            targetGlucose: currentGlucoseTarget,
            glucoseColorScheme: glucoseColorScheme
        )
    }

    private func drawGlucoseChart() -> some ChartContent {
        ForEach(glucoseData) { item in
            let glucoseToDisplay = units == .mgdL ? Decimal(item.glucose) : Decimal(item.glucose).asMmolL

            if item.isManual {
                PointMark(
                    x: .value("Time", item.date ?? Date(), unit: .second),
                    y: .value("Value", glucoseToDisplay)
                )
                .symbolSize(20)
                .symbol {
                    Image(systemName: "drop.fill")
                        .font(.caption2)
                        .symbolRenderingMode(.monochrome)
                        .bold()
                        .foregroundStyle(.red)
                }
            } else {
                PointMark(
                    x: .value("Time", item.date ?? Date(), unit: .second),
                    y: .value("Value", glucoseToDisplay)
                )
                .foregroundStyle(pointColor(for: item))
                .symbolSize(20)
                .symbol(.circle)
            }

            if isSmoothingEnabled, let smoothedGlucose = item.smoothedGlucose, smoothedGlucose != 0 {
                let smoothedGlucoseForDisplay: Decimal = units == .mgdL ? smoothedGlucose.decimalValue : smoothedGlucose
                    .decimalValue.asMmolL
                LineMark(
                    x: .value("Time", item.date ?? Date(), unit: .second),
                    y: .value("Value", smoothedGlucoseForDisplay),
                    series: .value("Type", "Smoothed")
                )
                .foregroundStyle(Color.secondary)
            }
        }
    }
}

#Preview {
    struct PreviewWrapper: View {
        @State private var previewStack: CoreDataStack? = nil
        @State private var glucoseData: [GlucoseStored] = []
        @State private var isLoading = true

        var body: some View {
            NavigationView {
                Group {
                    if isLoading {
                        ProgressView("Loading data...")
                    } else {
                        VStack {
                            Chart {
                                GlucoseChartView(
                                    glucoseData: glucoseData,
                                    units: .mgdL,
                                    highGlucose: 180,
                                    lowGlucose: 70,
                                    currentGlucoseTarget: 100,
                                    isSmoothingEnabled: false,
                                    glucoseColorScheme: .dynamicColor
                                )
                            }
                            .frame(height: 200)
                            .padding()
                        }
                    }
                }
                .navigationTitle("Glucose Chart")
                .task {
                    // Use the preview stack that's initialized asynchronously in CoreDataStack
                    previewStack = try? await CoreDataStack.preview()

                    // Now you can safely create preview data
                    if let stack = previewStack {
                        glucoseData = GlucoseStored.makePreviewGlucose(count: 24, provider: stack)
                        isLoading = false
                    }
                }
            }
        }
    }

    return PreviewWrapper()
}