PushNotificationListViewModel.swift

//
//  PushNotificationListViewModel.swift
//  DevLog
//
//  Created by 최윤진 on 11/22/25.
//

import Foundation

@Observable
final class PushNotificationListViewModel: Store {
    struct State: Equatable {
        var notifications: [PushNotificationItem] = []
        var showAlert: Bool = false
        var showToast: Bool = false
        var alertTitle: String = ""
        var alertMessage: String = ""
        var toastMessage: String = ""
        var isLoading: Bool = false
        var hasMore: Bool = false
        var nextCursor: PushNotificationCursor?
        var query: PushNotificationQuery
        var selectedTodoID: TodoIDItem?
    }

    enum Action {
        case fetchNotifications
        case loadNextPage
        case deleteNotification(PushNotificationItem)
        case toggleRead(PushNotificationItem)
        case undoDelete
        case confirmDelete
        case setAlert(isPresented: Bool)
        case setToast(isPresented: Bool)
        case setLoading(Bool)
        case appendNotifications([PushNotificationItem], nextCursor: PushNotificationCursor?)
        case resetPagination
        case setHasMore(Bool)
        case toggleSortOption
        case setTimeFilter(PushNotificationQuery.TimeFilter)
        case toggleUnreadOnly
        case resetFilters
        case tapNotification(PushNotificationItem)
        case setSelectedTodoID(TodoIDItem?)
    }

    enum SideEffect {
        case fetchNotifications(PushNotificationQuery, cursor: PushNotificationCursor?)
        case delete(PushNotificationItem)
        case toggleRead(String)
    }

    private(set) var state: State
    private let fetchUseCase: FetchPushNotificationsUseCase
    private let deleteUseCase: DeletePushNotificationUseCase
    private let toggleReadUseCase: TogglePushNotificationReadUseCase
    private let fetchQueryUseCase: FetchPushNotificationQueryUseCase
    private let updateQueryUseCase: UpdatePushNotificationQueryUseCase
    private var pendingTask: (PushNotificationItem, Int)?

    init(
        fetchUseCase: FetchPushNotificationsUseCase,
        deleteUseCase: DeletePushNotificationUseCase,
        toggleReadUseCase: TogglePushNotificationReadUseCase,
        fetchQueryUseCase: FetchPushNotificationQueryUseCase,
        updateQueryUseCase: UpdatePushNotificationQueryUseCase
    ) {
        self.fetchUseCase = fetchUseCase
        self.deleteUseCase = deleteUseCase
        self.toggleReadUseCase = toggleReadUseCase
        self.fetchQueryUseCase = fetchQueryUseCase
        self.updateQueryUseCase = updateQueryUseCase
        self.state = State(
            query: fetchQueryUseCase.execute()
        )
    }

    var appliedFilterCount: Int {
        var count = 0
        if state.query.sortOrder != .latest { count += 1 }
        if state.query.timeFilter != .none { count += 1 }
        if state.query.unreadOnly { count += 1 }
        return count
    }

    func reduce(with action: Action) -> [SideEffect] {
        var state = self.state
        var effects: [SideEffect] = []

        switch action {
        case .deleteNotification, .toggleRead, .undoDelete, .setAlert, .toggleSortOption,
                .setTimeFilter, .toggleUnreadOnly, .resetFilters, .tapNotification:
            effects = reduceByUser(action, state: &state)

        case .fetchNotifications, .confirmDelete, .setToast, .setSelectedTodoID, .loadNextPage:
            effects = reduceByView(action, state: &state)

        case .setLoading, .appendNotifications, .resetPagination, .setHasMore:
            effects = reduceByRun(action, state: &state)
        }

        if self.state != state { self.state = state }
        return effects
    }

    func run(_ effect: SideEffect) {
        switch effect {
        case .fetchNotifications(let query, let cursor):
            Task {
                do {
                    defer { send(.setLoading(false)) }
                    send(.setLoading(true))

                    let page = try await fetchUseCase.execute(query, cursor: cursor)

                    if cursor == nil { send(.resetPagination) }
                    send(
                        .appendNotifications(
                            page.items.map { PushNotificationItem(from: $0) },
                            nextCursor: page.nextCursor
                        )
                    )

                    let hasMore = page.items.count == query.pageSize && page.nextCursor != nil
                    send(.setHasMore(hasMore))
                } catch {
                    send(.setAlert(isPresented: true))
                }

            }
        case .delete(let notification):
            Task {
                do {
                    defer { send(.setLoading(false)) }
                    send(.setLoading(true))
                    try await deleteUseCase.execute(notification.id)
                } catch {
                    send(.setAlert(isPresented: true))
                }
            }
        case .toggleRead(let todoID):
            Task {
                do {
                    defer { send(.setLoading(false)) }
                    send(.setLoading(true))
                    try await toggleReadUseCase.execute(todoID)
                } catch {
                    send(.setAlert(isPresented: true))
                }
            }
        }
    }
}

// MARK: - Reduce Methods
private extension PushNotificationListViewModel {
    func reduceByUser(_ action: Action, state: inout State) -> [SideEffect] {
        switch action {
        case .deleteNotification(let item):
            var effects: [SideEffect] = []
            if let (pendingItem, _) = pendingTask {
                effects = [.delete(pendingItem)]
            }

            if let index = state.notifications.firstIndex(where: { $0.id == item.id }) {
                pendingTask = (item, index)
                state.notifications.remove(at: index)
                setToast(&state, isPresented: true)
            }

            return effects
        case .toggleRead(let item):
            if let index = state.notifications.firstIndex(where: { $0.id == item.id }) {
                state.notifications[index].isRead.toggle()
                return [.toggleRead(item.todoID)]
            }
        case .undoDelete:
            guard let (item, index) = pendingTask else { return [] }
            state.notifications.insert(item, at: index)
            pendingTask = nil
        case .setAlert(let isPresented):
            setAlert(&state, isPresented: isPresented)
        case .toggleSortOption:
            state.query.sortOrder = state.query.sortOrder == .latest ? .oldest : .latest
            updateQueryUseCase.execute(state.query)
            state.nextCursor = nil
            return [.fetchNotifications(state.query, cursor: nil)]
        case .setTimeFilter(let filter):
            state.query.timeFilter = filter
            updateQueryUseCase.execute(state.query)
            state.nextCursor = nil
            return [.fetchNotifications(state.query, cursor: nil)]
        case .toggleUnreadOnly:
            state.query.unreadOnly.toggle()
            updateQueryUseCase.execute(state.query)
            state.nextCursor = nil
            return [.fetchNotifications(state.query, cursor: nil)]
        case .resetFilters:
            state.query = .default
            updateQueryUseCase.execute(state.query)
            state.nextCursor = nil
            return [.fetchNotifications(state.query, cursor: nil)]
        case .tapNotification(let item):
            state.selectedTodoID = TodoIDItem(id: item.todoID)
            if let index = state.notifications.firstIndex(where: { $0.id == item.id }), !item.isRead {
                state.notifications[index].isRead.toggle()
                return [.toggleRead(item.todoID)]
            }
        default:
            break
        }
        return []
    }

    func reduceByView(_ action: Action, state: inout State) -> [SideEffect] {
        switch action {
        case .fetchNotifications:
            state.nextCursor = nil
            return [.fetchNotifications(state.query, cursor: nil)]
        case .loadNextPage:
            guard state.hasMore, !state.isLoading, pendingTask == nil else { return [] }
            return [.fetchNotifications(state.query, cursor: state.nextCursor)]
        case .confirmDelete:
            guard let (item, _) = pendingTask else { return [] }
            pendingTask = nil
            return [.delete(item)]
        case .setToast(let isPresented):
            setToast(&state, isPresented: isPresented)
        case .setSelectedTodoID(let todoID):
            state.selectedTodoID = todoID
        default:
            break
        }
        return []
    }

    func reduceByRun(_ action: Action, state: inout State) -> [SideEffect] {
        switch action {
        case .setLoading(let value):
            state.isLoading = value
        case .setHasMore(let value):
            state.hasMore = value
        case .resetPagination:
            state.notifications = []
            state.nextCursor = nil
        case .appendNotifications(let notifications, let nextCursor):
            let filteredNotifications: [PushNotificationItem]
            if let (pendingItem, _) = pendingTask {
                filteredNotifications = notifications.filter { $0.id != pendingItem.id }
            } else {
                filteredNotifications = notifications
            }
            state.notifications.append(contentsOf: filteredNotifications)
            state.nextCursor = nextCursor
        default:
            break
        }
        return []
    }
}

private extension PushNotificationListViewModel {
    func setAlert(
        _ state: inout State,
        isPresented: Bool
    ) {
        state.alertTitle = "오류"
        state.alertMessage = "문제가 발생했습니다. 잠시 후 다시 시도해주세요."
        state.showAlert = isPresented
    }

    func setToast(
        _ state: inout State,
        isPresented: Bool
    ) {
        state.toastMessage = "실행 취소"
        state.showToast = isPresented
    }
}

extension PushNotificationQuery.SortOrder {
    var title: String {
        switch self {
        case .latest: return "최신순"
        case .oldest: return "예전순"
        }
    }
}

extension PushNotificationQuery.TimeFilter {
    var id: String {
        switch self {
        case .none: return "none"
        case .hours(let value): return "hours-\(value)"
        case .days(let value): return "days-\(value)"
        }
    }

    var title: String {
        switch self {
        case .none:
            return "전체"
        case .hours(let value):
            return "최근 \(value)시간"
        case .days(let value):
            return "최근 \(value)일"
        }
    }

    static var availableOptions: [PushNotificationQuery.TimeFilter] {[
            .none,
            .hours(1),
            .hours(6),
            .hours(24),
            .days(3),
            .days(7)
        ]
    }

    init(id: String) {
        if id == "none" {
            self = .none
        } else if id.hasPrefix("hours-") {
            let value = Int(id.replacingOccurrences(of: "hours-", with: "")) ?? 0
            self = value > 0 ? .hours(value) : .none
        } else if id.hasPrefix("days-") {
            let value = Int(id.replacingOccurrences(of: "days-", with: "")) ?? 0
            self = value > 0 ? .days(value) : .none
        } else {
            self = .none
        }
    }
}