Reflect/Shared/Views/DayView/DayView.swift

//
//  HomeView.swift
//  Shared
//
//  Created by Trey Tartt on 1/5/22.
//

import SwiftUI
import SwiftData
import Charts

struct DayViewConstants {
    static let maxHeaderHeight = 200.0
    static let minHeaderHeight = 120.0
}

struct DayView: View {
    @AppStorage(UserDefaultsStore.Keys.deleteEnable.rawValue, store: GroupUserDefaults.groupDefaults) private var deleteEnabled = true

    @AppStorage(UserDefaultsStore.Keys.theme.rawValue, store: GroupUserDefaults.groupDefaults) private var theme: Theme = .system

    @AppStorage(UserDefaultsStore.Keys.moodImages.rawValue, store: GroupUserDefaults.groupDefaults) private var imagePack: MoodImages = .FontAwesome
    @AppStorage(UserDefaultsStore.Keys.moodTint.rawValue, store: GroupUserDefaults.groupDefaults) private var moodTint: MoodTints = .Default
    @AppStorage(UserDefaultsStore.Keys.textColor.rawValue, store: GroupUserDefaults.groupDefaults) private var textColor: Color = DefaultTextColor.textColor
    @AppStorage(UserDefaultsStore.Keys.dayViewStyle.rawValue, store: GroupUserDefaults.groupDefaults) private var dayViewStyle: DayViewStyle = .classic

    // store a value that gets changed when user updates custom colors to update the view since the moodTint doesn't change
    @AppStorage(UserDefaultsStore.Keys.customMoodTintUpdateNumber.rawValue, store: GroupUserDefaults.groupDefaults) private var customMoodTintUpdateNumber: Int = 0

    // MARK: edit row properties
    @State private var showingSheet = false
    @State private var selectedEntry: MoodEntryModel?
    @State private var showEntryDetail = false
    //

    // MARK: ?? properties
    @State private var showTodayInput = true
    @StateObject private var onboardingData = OnboardingDataDataManager.shared
    @StateObject private var filteredDays = DaysFilterClass.shared
    @EnvironmentObject var iapManager: IAPManager

    @ObservedObject var viewModel: DayViewViewModel

    var body: some View {
        ZStack {
            Text(String(customMoodTintUpdateNumber))
                .hidden()

            mainView
                .onAppear(perform: {
                    EventLogger.log(event: "show_home_view")
                })
                .sheet(isPresented: $showingSheet) {
                    SettingsView()
                }
                .onChange(of: selectedEntry) { _, newEntry in
                    if newEntry != nil {
                        showEntryDetail = true
                    }
                }
                .sheet(isPresented: $showEntryDetail, onDismiss: {
                    selectedEntry = nil
                }) {
                    if let entry = selectedEntry {
                        EntryDetailView(
                            entry: entry,
                            onMoodUpdate: { newMood in
                                viewModel.update(entry: entry, toMood: newMood)
                            },
                            onDelete: {
                                viewModel.update(entry: entry, toMood: .missing)
                            }
                        )
                    }
                }
        }
        .padding([.top])
    }


    // MARK: Views
    public var mainView: some View {
        VStack(spacing: 12) {
            if viewModel.hasNoData {
                Spacer()
                EmptyHomeView(showVote: true, viewModel: viewModel)
                Spacer()
            } else {
                headerView

                listView
            }
        }
        .padding([.leading, .trailing])
        .onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) { _ in
            DataController.shared.fillInMissingDates()
            viewModel.updateData()
        }
        .background(
            theme.currentTheme.bg
        )
    }

    private var headerView: some View {
        VStack {
            if ShowBasedOnVoteLogics.isMissingCurrentVote(onboardingData: UserDefaultsStore.getOnboarding()) {
                AddMoodHeaderView(addItemHeaderClosure: { (mood, date) in
                    viewModel.add(mood: mood, forDate: date, entryType: .header)
                })
            }
        }
    }

    private var listView: some View {
        ScrollView {
            LazyVStack(spacing: 8, pinnedViews: [.sectionHeaders]) {
                ForEach(viewModel.grouped.sorted(by: {
                    $0.key > $1.key
                }), id: \.key) { year, months in

                    // for reach month
                    ForEach(months.sorted(by: {
                        $0.key > $1.key
                    }), id: \.key) { month, entries in
                        Section(header: SectionHeaderView(month: month, year: year)) {
                            monthListView(month: month, year: year, entries: entries)
                        }
                    }
                }
            }
            .padding(.bottom, 20)
        }
        .background(
            theme.currentTheme.secondaryBGColor
        )
        .cornerRadius(Constants.viewsCornerRaidus, corners: [.topLeft, .topRight])
    }
}

// view that make up the list body
extension DayView {
    private func SectionHeaderView(month: Int, year: Int) -> some View {
        HStack(spacing: 10) {
            // Calendar icon
            Image(systemName: "calendar")
                .font(.system(size: 16, weight: .semibold))
                .foregroundColor(textColor.opacity(0.6))

            Text("\(Random.monthName(fromMonthInt: month)) \(String(year))")
                .font(.system(size: 20, weight: .bold, design: .rounded))
                .foregroundColor(textColor)

            Spacer()
        }
        .padding(.horizontal, 16)
        .padding(.vertical, 14)
        .background(.ultraThinMaterial)
    }

    private var gridColumns: [GridItem] {
        [
            GridItem(.flexible(), spacing: 10),
            GridItem(.flexible(), spacing: 10),
            GridItem(.flexible(), spacing: 10)
        ]
    }

    @ViewBuilder
    private func monthListView(month: Int, year: Int, entries: [MoodEntryModel]) -> some View {
        let filteredEntries = entries.sorted(by: { $0.forDate > $1.forDate })
            .filter { filteredDays.currentFilters.contains($0.weekDay) }

        if dayViewStyle.isGridLayout {
            // Grid layout - 3 per row
            LazyVGrid(columns: gridColumns, spacing: 10) {
                ForEach(filteredEntries, id: \.self) { entry in
                    EntryListView(entry: entry)
                        .contentShape(Rectangle())
                        .onTapGesture {
                            selectedEntry = entry
                        }
                }
            }
            .padding(.horizontal, 12)
            .padding(.top, 8)
        } else {
            // Standard vertical layout
            VStack(spacing: 12) {
                ForEach(filteredEntries, id: \.self) { entry in
                    EntryListView(entry: entry)
                        .contentShape(Rectangle())
                        .onTapGesture {
                            selectedEntry = entry
                        }
                }
            }
            .padding(.horizontal, 12)
            .padding(.top, 8)
        }
    }
}

struct ViewOffsetKey: PreferenceKey {
    typealias Value = CGFloat
    static var defaultValue = CGFloat.zero
    static func reduce(value: inout Value, nextValue: () -> Value) {
        value += nextValue()
    }
}

struct DayView_Previews: PreviewProvider {
    static var previews: some View {
        DayView(viewModel: DayViewViewModel(addMonthStartWeekdayPadding: false))
            .modelContainer(DataController.shared.container)
            .onAppear(perform: {
                DataController.shared.populateMemory()
            })

        DayView(viewModel: DayViewViewModel(addMonthStartWeekdayPadding: false))
            .preferredColorScheme(.dark)
            .modelContainer(DataController.shared.container)
    }
}