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 FeatureCategorySharing
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)
        case 링크공유(CategorySharingFeature.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)
        case 링크공유(CategorySharingFeature.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() }
        Scope(state: \.링크공유, action: \.링크공유) { CategorySharingFeature() }
    }
}

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()
                guard let lastPath = state.path.last else { return .none }
                switch lastPath {
                case .링크공유:
                    state.path.removeLast()
                    return .none
                default: return .none
                }

            /// - 포킷 카테고리 아이템 눌렀을 때
            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.링크_저장_완료_문구))), animation: .pokitSpring)
                    )
                default:
                    return .send(.inner(.링크팝업_활성화(.success(title: Constants.링크_저장_완료_문구))), animation: .pokitSpring)
                }
            case .recommend(.delegate(.저장하기_완료)):
                return .send(.inner(.링크팝업_활성화(.success(title: Constants.링크_저장_완료_문구))), 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 let .inner(.공유포킷_이동(sharedCategory: sharedCategory)):
                state.path.append(.링크공유(CategorySharingFeature.State(sharedCategory: sharedCategory)))
                return .none
                
            /// 링크 공유에서 컨텐츠 상세보기
            case let .path(.element(_, action: .링크공유(.delegate(.컨텐츠_아이템_클릭(categoryId: categoryId, content: content))))):
                state.contentDetail = ContentDetailFeature.State(content: BaseContentDetail(
                    id: content.id,
                    category: BaseCategoryInfo(
                        categoryId: categoryId,
                        categoryName: content.categoryName
                    ),
                    title: content.title,
                    data: content.data,
                    memo: content.memo ?? "",
                    createdAt: content.createdAt,
                    favorites: nil,
                    alertYn: .no
                ))
                return .none
            
            case let .path(.element(_, action: .링크공유(.delegate(.공유받은_카테고리_추가(sharedCategory))))):
                let category = BaseCategoryItem(
                    id: sharedCategory.categoryId,
                    userId: 0,
                    categoryName: sharedCategory.categoryName,
                    categoryImage: BaseCategoryImage(
                        imageId: sharedCategory.categoryImageId,
                        imageURL: sharedCategory.categoryImageUrl
                    ),
                    contentCount: sharedCategory.contentCount,
                    createdAt: "",
                    openType: .공개,
                    keywordType: .default,
                    userCount: 0,
                    isFavorite: false
                )
                state.path.append(.포킷추가및수정(PokitCategorySettingFeature.State(
                    type: .공유추가,
                    category: category
                )))
                return .none
            case .path(.element(_, action: .알림함(.delegate(.alertBoxDismiss)))):
                state.path.popLast()
                return .none
            default: return .none
            }
        }
        .forEach(\.path, action: \.path) { MainTabPath() }
    }
}