everything changed

Shared/views/HomeView/HomeView.swift

@@ -0,0 +1,363 @@
+//
+//  HomeView.swift
+//  Shared
+//
+//  Created by Trey Tartt on 1/5/22.
+//
+
+import SwiftUI
+import CoreData
+import Charts
+
+struct HomeViewConstants {
+    static let maxHeaderHeight = 200.0
+    static let minHeaderHeight = 120.0
+}
+
+struct HomeView: View {
+    @Environment(\.managedObjectContext) private var viewContext
+    
+    @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
+
+    // MARK: top header storage
+    @AppStorage(UserDefaultsStore.Keys.contentViewCurrentSelectedHeaderViewBackDays.rawValue, store: GroupUserDefaults.groupDefaults) private var currentSelectedHeaderViewBackDays: Int = 30
+    @AppStorage(UserDefaultsStore.Keys.contentViewHeaderTagViewOneViewType.rawValue, store: GroupUserDefaults.groupDefaults) private var firstSwichableHeaderViewType: MainSwitchableViewType = .total
+    @AppStorage(UserDefaultsStore.Keys.contentViewHeaderTagViewTwoViewType.rawValue, store: GroupUserDefaults.groupDefaults) private var secondSwichableHeaderViewType: MainSwitchableViewType = .total
+    @AppStorage(UserDefaultsStore.Keys.contentViewHeaderTag.rawValue, store: GroupUserDefaults.groupDefaults) private var switchableViewSelectedIndex = 1
+    @AppStorage(UserDefaultsStore.Keys.currentSelectedHeaderViewViewType.rawValue, store: GroupUserDefaults.groupDefaults) private var currentSelectedHeaderViewViewType: MainSwitchableViewType = .total
+    //
+    
+    // MARK: edit row properties
+    @State private var showingSheet = false
+    @State private var selectedEntry: MoodEntry?
+    //
+    
+    // MARK: ?? properties
+    @State private var showTodayInput = true
+    @State private var showUpdateEntryAlert = false
+    @StateObject private var onboardingData = OnboardingDataDataManager.shared
+    
+    // MARK: header properties
+    @State private var headerHeight: CGFloat = HomeViewConstants.maxHeaderHeight
+    @State private var headerViewType: MainSwitchableViewType = .total
+    @State private var headerOpacity: Double = 1.0
+    //
+    
+    @ObservedObject var viewModel = HomeViewViewModel(addMonthStartWeekdayPadding: false)
+
+    var body: some View {
+        mainView
+            .alert(HomeViewViewModel.updateTitleHeader(forEntry: selectedEntry),
+                   isPresented: $showUpdateEntryAlert) {
+                ForEach(Mood.allValues) { mood in
+                    Button(mood.strValue, action: {
+                        if let selectedEntry = selectedEntry {
+                            viewModel.update(entry: selectedEntry, toMood: mood)
+                        }
+                        showUpdateEntryAlert = false
+                        selectedEntry = nil
+                    })
+                }
+                
+                if let selectedEntry = selectedEntry,
+                   deleteEnabled,
+                   selectedEntry.mood != .missing {
+                    Button(String(localized: "content_view_delete_entry"), action: {
+                        viewModel.update(entry: selectedEntry, toMood: Mood.missing)
+                        showUpdateEntryAlert = false
+                    })
+                }
+                
+                Button(String(localized: "content_view_fill_in_missing_entry_cancel"), role: .cancel,  action: {
+                    selectedEntry = nil
+                    showUpdateEntryAlert = false
+                })
+            }
+    }
+    
+    // MARK: functions that do view type work
+    func calcuateViewAlpha() {
+        let perc = (((Double(headerHeight) - HomeViewConstants.minHeaderHeight) * 100) / (HomeViewConstants.maxHeaderHeight - HomeViewConstants.minHeaderHeight)) / 100
+        headerOpacity = perc
+    }
+    
+    func calculateHeight(minHeight: CGFloat, maxHeight: CGFloat, yOffset: CGFloat) {
+        let newValue = maxHeight + yOffset
+        
+        calcuateViewAlpha()
+        // If scrolling up, yOffset will be a negative number
+        if newValue < minHeight {
+            // SCROLLING UP
+            // Never go smaller than our minimum height
+            headerHeight = minHeight
+            return
+        }
+        
+        if newValue > maxHeight {
+            // SCROLLING UP
+            // Never go smaller than our minimum height
+            headerHeight = maxHeight
+            return
+        }
+        
+        // SCROLLING DOWN
+        headerHeight = newValue
+    }
+        
+    // MARK: Views
+    public var mainView: some View {
+        VStack {
+            settingsButtonView
+            if viewModel.hasNoData {
+                Spacer()
+                EmptyHomeView(viewModel: viewModel)
+                Spacer()
+            } else {
+                ZStack {
+                    VStack {
+                        headerView
+                        Spacer()
+                    }
+                    .opacity(headerOpacity)
+                    
+                    VStack {
+                        SmallRollUpHeaderView(entries: getBackEntries(),
+                                              viewType: $currentSelectedHeaderViewViewType)
+                            .frame(height: HomeViewConstants.minHeaderHeight)
+                            .padding([.trailing, .leading])
+                            .background(
+                                theme.currentTheme.secondaryBGColor
+                            )
+                            .cornerRadius(10, corners: [.topLeft, .topRight, .bottomLeft, .bottomRight])
+                        
+                        Spacer()
+                    }
+                    .opacity(1 - headerOpacity)
+                }
+                .frame(height: headerHeight + 20)
+                
+                
+                listView
+                    .padding(.top, -25)
+            }
+        }
+        .padding()
+        .padding(.bottom, 5)
+        .background(
+            theme.currentTheme.bg
+                .edgesIgnoringSafeArea(.all)
+        )
+        .onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) { _ in
+            PersistenceController.shared.fillInMissingDates()
+            viewModel.updateData()
+        }
+    }
+    
+    private var settingsButtonView: some View {
+        HStack {
+            Spacer()
+            Button(action: {
+                showingSheet.toggle()
+            }, label: {
+                Image(systemName: "gear")
+                    .foregroundColor(Color(UIColor.darkGray))
+                    .font(.system(size: 20))
+            }).sheet(isPresented: $showingSheet) {
+                SettingsView(editedDataClosure: {
+                    withAnimation{
+                        viewModel.updateData()
+                    }
+                })
+            }.padding(.trailing)
+        }
+    }
+    
+    private var headerView: some View {
+        VStack {
+            if ShowBasedOnVoteLogics.isMissingCurrentVote(onboardingData: onboardingData.savedOnboardingData) {
+                AddMoodHeaderView(addItemHeaderClosure: { (mood, date) in
+                    withAnimation {
+                        viewModel.add(mood: mood, forDate: date, entryType: .header)
+                    }
+                })
+                    .frame(height: headerHeight)
+                    .frame(minWidth: 0, maxWidth: .infinity)
+            } else {
+                // selection hre doesn't work ...
+                TabView(selection: $switchableViewSelectedIndex) {
+                    SwitchableView(daysBack: 30,
+                                   viewType: $firstSwichableHeaderViewType,
+                                   headerTypeChanged: { viewType in
+                        firstSwichableHeaderViewType = viewType
+                        currentSelectedHeaderViewViewType = firstSwichableHeaderViewType
+                    })
+                        .tag(1)
+                        .frame(height: headerHeight)
+                        .frame(minWidth: 0, maxWidth: .infinity)
+                        .contentShape(Rectangle())
+                    
+                    SwitchableView(daysBack: 7,
+                                   viewType: $secondSwichableHeaderViewType,
+                                   headerTypeChanged: { viewType in
+                        secondSwichableHeaderViewType = viewType
+                        currentSelectedHeaderViewViewType = secondSwichableHeaderViewType
+                    })
+                        .tag(2)
+                        .frame(height: headerHeight)
+                        .frame(minWidth: 0, maxWidth: .infinity)
+                        .contentShape(Rectangle())
+                }
+                .tabViewStyle(.page)
+                .onChange(of: switchableViewSelectedIndex) { value in
+                    if value == 1 {
+                        currentSelectedHeaderViewBackDays = 30
+                        currentSelectedHeaderViewViewType = firstSwichableHeaderViewType
+                    }
+                    
+                    if value == 2 {
+                        currentSelectedHeaderViewBackDays = 7
+                        currentSelectedHeaderViewViewType = secondSwichableHeaderViewType
+                    }
+                }
+            }
+        }
+    }
+    
+    private var listView: some View {
+        ScrollView {
+            LazyVStack(spacing: 5, 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)
+                        }
+                    }
+                }
+            }.background(
+                GeometryReader { proxy in
+                    let offset = proxy.frame(in: .named("scroll")).minY
+                    Color.clear.preference(key: ViewOffsetKey.self, value: offset)
+                }
+            )
+        }
+        .background(
+            theme.currentTheme.secondaryBGColor
+        )
+        .coordinateSpace(name: "scroll")
+        .onPreferenceChange(ViewOffsetKey.self) { value in
+            if viewModel.numberOfItems > 10 {
+                calculateHeight(minHeight: HomeViewConstants.minHeaderHeight,
+                                maxHeight: HomeViewConstants.maxHeaderHeight,
+                                yOffset: value)
+            }
+        }
+        .cornerRadius(10, corners: [.topLeft, .topRight])
+    }
+    
+    func getBackEntries() -> [MoodEntry] {
+        var daysAgo = Calendar.current.date(byAdding: .day, value: -self.currentSelectedHeaderViewBackDays, to: Date())!
+        daysAgo = Calendar.current.date(bySettingHour: 0, minute: 0, second: 0, of: daysAgo)!
+        
+        return PersistenceController.shared.getData(startDate: daysAgo, endDate: Date(), includedDays: [1,2,3,4,5,6,7])
+    }
+}
+
+// view that make up the list body
+extension HomeView {
+    private func SectionHeaderView(month: Int, year: Int) -> some View {
+        Text("\(Random.monthName(fromMonthInt: month)) \(String(year))")
+            .font(.title)
+            .foregroundColor(theme.currentTheme.labelColor)
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding()
+            .background(
+                theme.currentTheme.secondaryBGColor
+            )
+    }
+    
+    private func monthListView(month: Int, year: Int, entries: [MoodEntry]) -> some View {
+        VStack {
+            // for reach all entries
+            ForEach(entries.sorted(by: {
+                return $0.forDate! > $1.forDate!
+            }), id: \.self) { entry in
+                entryListView(entry: entry)
+                    .contentShape(Rectangle())
+                    .onTapGesture(perform: {
+                        selectedEntry = entry
+                        showUpdateEntryAlert = true
+                    })
+            }
+        }
+    }
+    
+    private func entryListView(entry: MoodEntry) -> some View {
+        HStack {
+            imagePack.icon(forMood: entry.mood)
+                .resizable()
+                .aspectRatio(contentMode: .fit)
+                .frame(width: 40, height: 40, alignment: .center)
+                .foregroundColor(moodTint.color(forMood: entry.mood))
+                .padding(.leading, 5)
+            
+            VStack {
+                HStack {
+                    Text(Random.weekdayName(fromDate:entry.forDate!))
+                        .font(.title3)
+                        .foregroundColor(theme.currentTheme.labelColor)
+                    Text(" - ")
+                        .padding([.leading, .trailing], -10)
+                    Text(Random.dayFormat(fromDate:entry.forDate!))
+                        .font(.title3)
+                        .foregroundColor(theme.currentTheme.labelColor)
+                    Spacer()
+                }
+                .multilineTextAlignment(.leading)
+                
+                Text(entry.moodValue == Mood.missing.rawValue ? String(localized: "mood_value_missing_tap_to_add") :  "\(entry.moodString)")
+                    .font(.body)
+                    .foregroundColor(Color(UIColor.systemGray))
+                    .frame(maxWidth: .infinity, alignment: .leading)
+            }
+        }
+    }
+}
+
+struct ViewOffsetKey: PreferenceKey {
+    typealias Value = CGFloat
+    static var defaultValue = CGFloat.zero
+    static func reduce(value: inout Value, nextValue: () -> Value) {
+        value += nextValue()
+    }
+}
+
+private let itemFormatter: DateFormatter = {
+    let formatter = DateFormatter()
+    formatter.dateStyle = .short
+    formatter.timeStyle = .medium
+    return formatter
+}()
+
+struct ContentView_Previews: PreviewProvider {
+    static var previews: some View {
+        HomeView().environment(\.managedObjectContext, PersistenceController.shared.viewContext)
+            .onAppear(perform: {
+                PersistenceController.shared.populateMemory()
+            })
+        
+        HomeView()
+            .preferredColorScheme(.dark)
+            .environment(\.managedObjectContext, PersistenceController.shared.viewContext)
+    }
+}

Shared/views/HomeView/HomeViewTwo/HomeViewTwo.swift

@@ -0,0 +1,170 @@
+//
+//  HomeViewTwo.swift
+//  Feels (iOS)
+//
+//  Created by Trey Tartt on 2/18/22.
+//
+
+import SwiftUI
+
+struct HomeViewTwo: View {
+    @AppStorage(UserDefaultsStore.Keys.needsOnboarding.rawValue, store: GroupUserDefaults.groupDefaults) private var needsOnboarding = true
+    
+    @AppStorage(UserDefaultsStore.Keys.theme.rawValue, store: GroupUserDefaults.groupDefaults) private var theme: Theme = .system
+    @AppStorage(UserDefaultsStore.Keys.moodTint.rawValue, store: GroupUserDefaults.groupDefaults) private var moodTint: MoodTints = .Default
+    
+    @ObservedObject var viewModel = HomeViewViewModel(addMonthStartWeekdayPadding: true)
+    
+    @StateObject private var selectedDetail = StupidAssDetailViewObservableObject()
+    @State private var showingSheet = false
+    @StateObject private var onboardingData = OnboardingDataDataManager.shared
+    
+    class StupidAssDetailViewObservableObject: ObservableObject {
+        @Published var fuckingWrapped: MonthDetailView? = nil
+        @Published var showFuckingSheet = false
+    }
+    
+    let columns = [
+        GridItem(.flexible(minimum: 5, maximum: 400)),
+        GridItem(.flexible(minimum: 5, maximum: 400)),
+        GridItem(.flexible(minimum: 5, maximum: 400)),
+        GridItem(.flexible(minimum: 5, maximum: 400)),
+        GridItem(.flexible(minimum: 5, maximum: 400)),
+        GridItem(.flexible(minimum: 5, maximum: 400)),
+        GridItem(.flexible(minimum: 5, maximum: 400))
+    ]
+    
+    var body: some View {
+        ZStack {
+            if viewModel.hasNoData {
+                settingsButtonView
+                VStack {
+                    Spacer()
+                    EmptyHomeView(viewModel: viewModel)
+                        .padding()
+                    Spacer()
+                }
+            } else {
+                ScrollView {
+                    ZStack {
+                        topView
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                            .frame(height: 250)
+                            .background(
+                                .blue
+                            )
+                        settingsButtonView
+                    }
+                    LazyVStack(spacing: 5, 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() {
+                                    homeViewTwoMonthListView(month: month, year: year, entries: entries)
+                                }
+                            }
+                            .padding(.bottom)
+                        }
+                        .padding()
+                        .background(
+                            RoundedRectangle(cornerRadius: 10)
+                                .foregroundColor(
+                                    theme.currentTheme.secondaryBGColor
+                                )
+                        )
+                    }
+                    .padding([.leading, .trailing])
+                }.sheet(isPresented: $selectedDetail.showFuckingSheet,
+                        onDismiss: didDismiss) {
+                    selectedDetail.fuckingWrapped
+                }
+                        .edgesIgnoringSafeArea(.top)
+            }
+        }
+        .background(
+                    theme.currentTheme.bg
+                        .edgesIgnoringSafeArea(.all)
+                )
+    }
+    
+    
+    func didDismiss() {
+        selectedDetail.showFuckingSheet = false
+        selectedDetail.fuckingWrapped = nil
+    }
+}
+
+extension HomeViewTwo {
+    private var topView: some View {
+        VStack {
+            if ShowBasedOnVoteLogics.isMissingCurrentVote(onboardingData: onboardingData.savedOnboardingData) {
+                Text("Vote")
+            }
+            Text("dis top")
+        }
+    }
+    
+    private var settingsButtonView: some View {
+        HStack {
+            Spacer()
+            VStack {
+                Button(action: {
+                    showingSheet.toggle()
+                }, label: {
+                    Image(systemName: "gear")
+                        .foregroundColor(Color(UIColor.darkGray))
+                        .font(.system(size: 20))
+                }).sheet(isPresented: $showingSheet) {
+                    SettingsView(editedDataClosure: {
+                        withAnimation{
+                            viewModel.updateData()
+                        }
+                    })
+                }
+                .padding(.top, 60)
+                .padding(.trailing)
+                Spacer()
+            }
+        }
+    }
+}
+
+// view that make up the list body
+extension HomeViewTwo {
+    private func homeViewTwoSectionHeaderView(month: Int, year: Int) -> some View {
+        Text("\(Random.monthName(fromMonthInt: month)) \(String(year))")
+            .font(.body)
+            .foregroundColor(theme.currentTheme.labelColor)
+            .frame(maxWidth: .infinity, alignment: .leading)
+    }
+    
+    private func homeViewTwoMonthListView(month: Int, year: Int, entries: [MoodEntry]) -> some View {
+        VStack {
+            homeViewTwoSectionHeaderView(month: month, year: year)
+            Divider()
+            LazyVGrid(columns: columns, spacing: 15) {
+                ForEach(entries, id: \.self) { entry in
+                    Circle()
+                        .foregroundColor(moodTint.color(forMood: entry.mood))
+                        .frame(minHeight: 5, idealHeight: 20, maxHeight: 50, alignment: .center)
+                }
+            }
+        }
+        .onTapGesture{
+            let deailView = MonthDetailView(monthInt: month,
+                                            yearInt: year,
+                                            entries: entries,
+                                            parentViewModel: viewModel)
+            
+            selectedDetail.fuckingWrapped = deailView
+            selectedDetail.showFuckingSheet = true
+        }
+    }
+}
+
+struct HomeViewTwo_Previews: PreviewProvider {
+    static var previews: some View {
+        HomeViewTwo()
+    }
+}

Shared/views/HomeView/HomeViewTwo/MonthDetailView.swift

@@ -0,0 +1,171 @@
+//
+//  MonthDetailView.swift
+//  Feels (iOS)
+//
+//  Created by Trey Tartt on 2/18/22.
+//
+
+import SwiftUI
+
+struct MonthDetailView: View {
+    @AppStorage(UserDefaultsStore.Keys.theme.rawValue, store: GroupUserDefaults.groupDefaults) private var theme: Theme = .system
+    @AppStorage(UserDefaultsStore.Keys.deleteEnable.rawValue, store: GroupUserDefaults.groupDefaults) private var deleteEnabled = true
+    @AppStorage(UserDefaultsStore.Keys.moodTint.rawValue, store: GroupUserDefaults.groupDefaults) private var moodTint: MoodTints = .Default
+
+    @State private var showingSheet = false
+    @State private var selectedEntry: MoodEntry?
+    @State private var showingUpdateEntryAlert = false
+    @State private var showUpdateEntryAlert = false
+    
+    let monthInt: Int
+    let yearInt: Int
+    @State var entries: [MoodEntry]
+    var parentViewModel: HomeViewViewModel
+    
+    let columns = [
+        GridItem(.flexible(minimum: 5, maximum: 50)),
+        GridItem(.flexible(minimum: 5, maximum: 50)),
+        GridItem(.flexible(minimum: 5, maximum: 50)),
+        GridItem(.flexible(minimum: 5, maximum: 50)),
+        GridItem(.flexible(minimum: 5, maximum: 50)),
+        GridItem(.flexible(minimum: 5, maximum: 50)),
+        GridItem(.flexible(minimum: 5, maximum: 50))
+    ]
+    
+    var body: some View {
+        VStack {
+            Text("\(Random.monthName(fromMonthInt: monthInt)) \(String(yearInt))")
+                .font(.title)
+                .foregroundColor(theme.currentTheme.labelColor)
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .padding()
+                .background(
+                    theme.currentTheme.secondaryBGColor
+                )
+            
+            createListView()
+                .padding([.leading, .trailing])
+                .background(
+                    theme.currentTheme.bg
+                )
+            
+            monthDetails
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .background(
+                    theme.currentTheme.secondaryBGColor
+                )
+        }
+        .alert(HomeViewViewModel.updateTitleHeader(forEntry: selectedEntry),
+               isPresented: $showUpdateEntryAlert) {
+            ForEach(Mood.allValues) { mood in
+                Button(mood.strValue, action: {
+                    if let selectedEntry = selectedEntry {
+                        PersistenceController.shared.update(entryDate: selectedEntry.forDate!, withModd: mood)
+                    }
+                    updateEntries()
+                    showUpdateEntryAlert = false
+                    selectedEntry = nil
+                })
+            }
+            
+            if let selectedEntry = selectedEntry,
+               deleteEnabled,
+               selectedEntry.mood != .missing {
+                Button(String(localized: "content_view_delete_entry"), action: {
+                    updateEntries()
+                    PersistenceController.shared.update(entryDate: selectedEntry.forDate!, withModd: .missing)
+                    showUpdateEntryAlert = false
+                })
+            }
+            
+            Button(String(localized: "content_view_fill_in_missing_entry_cancel"), role: .cancel,  action: {
+                updateEntries()
+                selectedEntry = nil
+                showUpdateEntryAlert = false
+            })
+        }
+               .background(
+                   theme.currentTheme.bg
+               )
+    }
+    
+    private func createListView() -> some View {
+        ScrollView {
+            LazyVGrid(columns: columns, spacing: 25) {
+                ForEach(entries, id: \.self) { entry in
+                    listViewEntry(forEntry: entry)
+                        .onTapGesture(perform: {
+                            if entry.canEdit {
+                                selectedEntry = entry
+                                showUpdateEntryAlert = true
+                            }
+                        })
+                }
+            }
+        }
+    }
+    
+    private func listViewEntry(forEntry entry: MoodEntry) -> some View {
+        VStack {
+            if entry.mood == .placeholder {
+                Text(" ")
+                    .font(.title3)
+                    .foregroundColor(Mood.placeholder.color)
+            } else {
+                Text(entry.forDate!,
+                     format: Date.FormatStyle().day())
+                    .font(.title3)
+                    .foregroundColor(theme.currentTheme.labelColor)
+            }
+            
+            if entry.mood == .placeholder {
+                Circle()
+                    .frame(minWidth: 5,
+                           maxWidth: 50,
+                           minHeight: 5,
+                           maxHeight: 50,
+                           alignment: .center)
+                    .foregroundColor(moodTint.color(forMood: entry.mood))
+            } else {
+                entry.mood.icon
+                    .resizable()
+                    .aspectRatio(contentMode: .fit)
+                    .frame(minWidth: 5,
+                           maxWidth: 50,
+                           minHeight: 5,
+                           maxHeight: 50,
+                           alignment: .center)
+                    .foregroundColor(moodTint.color(forMood: entry.mood))
+            }
+        }
+    }
+    
+    private func updateEntries() {
+        parentViewModel.updateData()
+        let (startDate, endDate) = Date.dateRange(monthInt: monthInt, yearInt: yearInt)
+        let updatedEntries = PersistenceController.shared.getData(startDate: startDate, endDate: endDate, includedDays: [1,2,3,4,5,6,7])
+        let padded = MoodEntryFunctions.padMoodEntriesMonth(monthEntries: updatedEntries)
+        entries = padded
+    }
+    
+    private var monthDetails: some View {
+        VStack {
+            SmallRollUpHeaderView(entries: entries,
+                                  viewType: .constant(.total))
+            
+            SmallRollUpHeaderView(entries: entries,
+                                  viewType: .constant(.percentageCircle))
+                .padding(.top, -20)
+        }
+        .padding()
+    }
+}
+
+struct MonthDetailView_Previews: PreviewProvider {
+    static var previews: some View {
+        MonthDetailView(monthInt: 5, yearInt: 2022, entries:
+                            PersistenceController.shared.randomEntries(count: 30).sorted(by: {
+            $0.forDate! < $1.forDate!
+        }), parentViewModel: HomeViewViewModel(addMonthStartWeekdayPadding: true))
+    }
+}

Shared/views/HomeView/HomeViewViewModel.swift

@@ -0,0 +1,127 @@
+//
+//  ContentModeViewModel.swift
+//  Feels (iOS)
+//
+//  Created by Trey Tartt on 1/20/22.
+//
+
+import SwiftUI
+import CoreData
+
+class HomeViewViewModel: ObservableObject {
+    @Published var grouped = [Int: [Int: [MoodEntry]]]()
+    @Published var numberOfItems = 0
+    
+    let addMonthStartWeekdayPadding: Bool
+    
+    var hasNoData: Bool {
+        grouped.isEmpty
+    }
+    
+    private var numberOfEntries: Int {
+        var num = 0
+        grouped.keys.forEach({
+            let year = grouped[$0]
+            let monthKeys = year?.keys
+            monthKeys?.forEach({
+                num += year![$0]!.count
+            })
+        })
+        return num
+        
+//        grouped.keys.map{
+//            grouped[$0]!.values.reduce(0) { sum, array in
+//                sum + array.count
+//            }
+//        }.reduce(0, +)
+    }
+    
+    init(addMonthStartWeekdayPadding: Bool) {
+        self.addMonthStartWeekdayPadding = addMonthStartWeekdayPadding
+        
+        PersistenceController.shared.switchContainerListeners.append {
+            self.getGroupedData(addMonthStartWeekdayPadding: self.addMonthStartWeekdayPadding)
+            
+        }
+        updateData()
+    }
+    
+    private func getGroupedData(addMonthStartWeekdayPadding: Bool) {
+        grouped = PersistenceController.shared.splitIntoYearMonth()
+        
+        if addMonthStartWeekdayPadding {
+            grouped = MoodEntryFunctions.padMoodEntriesForCalendar(entries: grouped)
+        }
+        
+        numberOfItems = numberOfEntries
+    }
+
+    
+
+    public func updateData() {
+        getGroupedData(addMonthStartWeekdayPadding: self.addMonthStartWeekdayPadding)
+    }
+    
+    public func add(mood: Mood, forDate date: Date, entryType: EntryType) {
+        PersistenceController.shared.add(mood: mood, forDate: date, entryType: entryType)
+        updateData()
+    }
+    
+    public func update(entry: MoodEntry, toMood mood: Mood) {
+        if PersistenceController.shared.update(entryDate: entry.forDate!, withModd: mood) {
+            updateData()
+        }
+    }
+    
+    public func delete(offsets: IndexSet, inMonth month: Int, inYear year: Int) {
+        if let monthEntries = grouped[year],
+           let entries = monthEntries[month] {
+            var mutableEntries = entries.sorted(by: {
+                $0.forDate! > $1.forDate!
+            })
+            var entriesToDelete = [MoodEntry]()
+            for idx in offsets {
+                let obj = mutableEntries.remove(at: idx)
+                entriesToDelete.append(obj)
+            }
+            entriesToDelete.forEach({ entry in
+                let entryDate = entry.forDate!
+                PersistenceController.shared.viewContext.delete(entry)
+                self.add(mood: .missing, forDate: entryDate, entryType: .listView)
+            })
+        }
+        
+        do {
+            try PersistenceController.shared.viewContext.save()
+            updateData()
+        } catch {
+            // Replace this implementation with code to handle the error appropriately.
+            // fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
+            let nsError = error as NSError
+            fatalError("Unresolved error \(nsError), \(nsError.userInfo)")
+        }
+    }
+    
+    static func updateTitleHeader(forEntry entry: MoodEntry?) -> String {
+        guard let entry = entry else {
+            return ""
+        }
+        
+        guard let forDate = entry.forDate else {
+            return ""
+        }
+        
+        let components = Calendar.current.dateComponents([.day, .month, .year], from: forDate)
+        //        let day = components.day!
+        let month = components.month!
+        let year = components.year!
+        
+        let monthName = Random.monthName(fromMonthInt: month)
+        let weekday = Random.weekdayName(fromDate:entry.forDate!)
+        let dayz = Random.dayFormat(fromDate:entry.forDate!)
+        
+        let string = weekday + " " + monthName + " " + dayz + " " + String(year)
+        
+        return String(format: String(localized: "content_view_fill_in_missing_entry"), string)
+    }
+}