MainTabPath.swift

//
//  MainTabPath.swift
//  App
//
//  Created by 김민호 on 7/29/24.
//

import Foundation

import ComposableArchitecture
import FeatureSetting
import FeatureCategoryDetail
import FeatureCategorySetting
import FeatureContentDetail
import FeatureContentSetting
import FeatureContentList
import Domain
import Util

@Reducer
public struct MainTabPath {
    @ObservableState
    public enum State: Equatable {
        case 알림함(PokitAlertBoxFeature.State)
        case 검색(PokitSearchFeature.State)
        case 설정(PokitSettingFeature.State)
        case 포킷추가및수정(PokitCategorySettingFeature.State)
        case 링크추가및수정(ContentSettingFeature.State)
        case 카테고리상세(CategoryDetailFeature.State)
        case 링크목록(ContentListFeature.State)
    }

    public enum Action {
        case 알림함(PokitAlertBoxFeature.Action)
        case 검색(PokitSearchFeature.Action)
        case 설정(PokitSettingFeature.Action)
        case 포킷추가및수정(PokitCategorySettingFeature.Action)
        case 링크추가및수정(ContentSettingFeature.Action)
        case 카테고리상세(CategoryDetailFeature.Action)
        case 링크목록(ContentListFeature.Action)
    }

    public var body: some Reducer<State, Action> {
        Scope(state: \.알림함, action: \.알림함) { PokitAlertBoxFeature() }
        Scope(state: \.검색, action: \.검색) { PokitSearchFeature() }
        Scope(state: \.설정, action: \.설정) { PokitSettingFeature() }
        Scope(state: \.포킷추가및수정, action: \.포킷추가및수정) { PokitCategorySettingFeature() }
        Scope(state: \.링크추가및수정, action: \.링크추가및수정) { ContentSettingFeature() }
        Scope(state: \.카테고리상세, action: \.카테고리상세) { CategoryDetailFeature() }
        Scope(state: \.링크목록, action: \.링크목록) { ContentListFeature() }
    }
}

public extension MainTabFeature {
    var navigationReducer: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            /// - 네비게이션 바 `알림`버튼 눌렀을 때
            case .pokit(.delegate(.alertButtonTapped)),
                 .recommend(.delegate(.알림_버튼_눌렀을때)),
                 .delegate(.알림함이동):
                state.isPushTapped = false
                state.path.append(.알림함(PokitAlertBoxFeature.State()))
                return .none

            /// - 네비게이션 바 `검색`버튼 눌렀을 때
            case .pokit(.delegate(.searchButtonTapped)),
                 .recommend(.delegate(.검색_버튼_눌렀을때)):
                state.path.append(.검색(PokitSearchFeature.State()))
                return .none

            /// - 네비게이션 바 `설정`버튼 눌렀을 때
            case .pokit(.delegate(.settingButtonTapped)):
                state.path.append(.설정(PokitSettingFeature.State()))
                return .none

            /// - 포킷 `수정`버튼 눌렀을 때
            case let .pokit(.delegate(.수정하기(category))),
                 let .path(.element(_, action: .카테고리상세(.delegate(.포킷수정(category))))):
                state.path.append(.포킷추가및수정(PokitCategorySettingFeature.State(
                    type: .수정,
                    category: category
                )))
                return .none
                
            case .recommend(.delegate(.컨텐츠_신고_API_반영)):
                return .send(.inner(.링크팝업_활성화(.report(title: "신고가 완료되었습니다"))))

            /// - 포킷 `추가` 버튼 눌렀을 때
            case .delegate(.포킷추가하기),
                 .path(.element(_, action: .링크추가및수정(.delegate(.포킷추가하기)))),
                 .pokit(.delegate(.포킷추가_버튼_눌렀을때)),
                 .recommend(.delegate(.포킷_추가하기_버튼_눌렀을때)):
                state.path.append(.포킷추가및수정(PokitCategorySettingFeature.State(type: .추가)))
                return .none

            /// - 포킷 `추가` or `수정`이 성공적으로 `완료`되었을 때
            case .path(.element(_, action: .포킷추가및수정(.delegate(.settingSuccess)))):
                state.path.removeLast()
                switch state.selectedTab {
                case .pokit: return .none
                case .recommend:
                    return .send(.recommend(.delegate(.포킷_추가하기_완료)))
                }

            /// - 포킷 카테고리 아이템 눌렀을 때
            case let .pokit(.delegate(.categoryTapped(category))):
                state.path.append(.카테고리상세(CategoryDetailFeature.State(category: category)))
                return .none

            case .path(.element(_, action: .카테고리상세(.delegate(.포킷삭제)))):
                /// Todo: id값을 받아와 삭제API 보내기
                state.path.removeLast()
                return .none

            /// - 링크 상세
            case let .path(.element(_, action: .카테고리상세(.delegate(.contentItemTapped(content))))),
                 let .pokit(.delegate(.contentDetailTapped(content))),
                 let .path(.element(_, action: .링크목록(.delegate(.링크상세(content: content))))),
                 let .path(.element(_, action: .검색(.delegate(.linkCardTapped(content: content))))):
                
                state.contentDetail = ContentDetailFeature.State(contentId: content.id)
                return .none

            /// - 링크상세 바텀시트에서 링크수정으로 이동
            case let .contentDetail(.presented(.delegate(.editButtonTapped(id)))),
                 let .pokit(.delegate(.링크수정하기(id))),
                 let .path(.element(_, action: .카테고리상세(.delegate(.링크수정(id))))),
                 let .path(.element(_, action: .링크목록(.delegate(.링크수정(id))))),
                 let .path(.element(_, action: .검색(.delegate(.링크수정(id))))),
                 let .path(.element(_, action: .알림함(.delegate(.moveToContentEdit(id))))):
                return .run { send in await send(.inner(.링크추가및수정이동(contentId: id))) }
            
            /// - 컨텐츠 상세보기 내부 액션 실행
            case .contentDetail(.presented(.delegate(.즐겨찾기_갱신_완료))),
                 .contentDetail(.presented(.delegate(.컨텐츠_조회_완료))),
                 .contentDetail(.presented(.delegate(.컨텐츠_삭제_완료))):
                guard
                    let stackElementId = state.path.ids.last,
                    let lastPath = state.path.last
                else {
                    switch state.selectedTab {
                    case .pokit:
                        return .send(.pokit(.delegate(.미분류_카테고리_컨텐츠_조회)))
                    case .recommend:
                        return .none
                    }
                }
                switch lastPath {
                case .링크목록:
                    return .send(.path(.element(id: stackElementId, action: .링크목록(.delegate(.컨텐츠_목록_조회)))))
                case .검색:
                    return .send(.path(.element(id: stackElementId, action: .검색(.delegate(.컨텐츠_검색)))))
                case .카테고리상세:
                    return .send(.path(.element(id: stackElementId, action: .카테고리상세(.delegate(.카테고리_내_컨텐츠_목록_조회)))))
                default: return .none
                }

            case let .inner(.링크추가및수정이동(contentId: id)):
                state.categoryId = nil
                state.contentDetail = nil
                state.path.append(.링크추가및수정(ContentSettingFeature.State(contentId: id)))
                return .none
            /// - 링크 추가하기
            case .delegate(.링크추가하기),
                 .pokit(.delegate(.링크추가_버튼_눌렀을때)):
                state.categoryId = nil
                state.path.append(.링크추가및수정(ContentSettingFeature.State(urlText: state.link)))
                state.link = nil
                return .none
                
            case let .path(.element(_, action: .카테고리상세(.delegate(.링크추가(categoryId))))):
                state.categoryId = categoryId
                state.path.append(.링크추가및수정(ContentSettingFeature.State()))
                return .none

            /// - 링크추가 및 수정에서 저장하기 눌렀을 때
            case let .path(.element(stackElementId, action: .링크추가및수정(.delegate(.저장하기_완료(contentId))))):
                state.categoryOfSavedContent = contentId
                state.path.removeLast()
                switch state.path.last {
                case .검색:
                    return .merge(
                        .send(.path(.element(id: stackElementId, action: .검색(.delegate(.컨텐츠_검색))))),
                        .send(.inner(.링크팝업_활성화(.success(title: Constants.링크_저장_완료_문구, until: 4))), animation: .pokitSpring)
                    )
                default:
                    return .send(.inner(.링크팝업_활성화(.success(title: Constants.링크_저장_완료_문구, until: 4))), animation: .pokitSpring)
                }
            case .recommend(.delegate(.저장하기_완료)):
                return .send(.inner(.링크팝업_활성화(.success(title: Constants.링크_저장_완료_문구, until: 4))), animation: .pokitSpring)
            /// - 각 화면에서 링크 복사 감지했을 때 (링크 추가 및 수정 화면 제외)
            case let .path(.element(_, action: .알림함(.delegate(.linkCopyDetected(url))))),
                 let .path(.element(_, action: .검색(.delegate(.linkCopyDetected(url))))),
                 let .path(.element(_, action: .설정(.delegate(.linkCopyDetected(url))))),
                 let .path(.element(_, action: .카테고리상세(.delegate(.linkCopyDetected(url))))),
                 let .path(.element(_, action: .포킷추가및수정(.delegate(.linkCopyDetected(url))))),
                 let .path(.element(_, action: .링크목록(.delegate(.linkCopyDetected(url))))):
                return .run { send in await send(.inner(.linkCopySuccess(url)), animation: .pokitSpring) }
            /// 바텀메세지
            case let .pokit(.delegate(.linkPopup(text))):
                state.linkPopup = .text(title: text)
                return .none
                
            case .path(.element(_, action: .설정(.delegate(.로그아웃)))):
                return .send(.delegate(.로그아웃))
            case .path(.element(_, action: .설정(.delegate(.회원탈퇴)))):
                return .send(.delegate(.회원탈퇴))

            case .path(.element(_, action: .알림함(.delegate(.alertBoxDismiss)))):
                let _ = state.path.popLast()
                return .none

            /// - 초대 수락 완료
            case .path(.element(_, action: .카테고리상세(.delegate(.초대_수락_완료)))):
                state.path.removeLast()
                return .send(.inner(.링크팝업_활성화(.success(title: "초대를 수락했습니다", until: 2))), animation: .pokitSpring)

            /// - 공유 포킷 저장 완료
            case .path(.element(_, action: .카테고리상세(.delegate(.저장_완료)))):
                state.path.removeLast()
                return .send(.inner(.링크팝업_활성화(.success(title: "포킷을 저장했습니다", until: 2))), animation: .pokitSpring)

            /// - 포킷 나가기 완료
            case .path(.element(_, action: .카테고리상세(.delegate(.포킷나가기)))):
                state.path.removeLast()
                return .send(.inner(.링크팝업_활성화(.success(title: "포킷에서 나갔습니다", until: 2))), animation: .pokitSpring)

            default: return .none
            }
        }
        .forEach(\.path, action: \.path) { MainTabPath() }
    }
}