//
//  UserRepository.swift
//  SodaLive
//
//  Created by klaus on 2023/08/09.
//

import Foundation
import CombineMoya
import Combine
import Moya

final class UserRepository {
    private let api = MoyaProvider<UserApi>()
    
    func login(request: LoginRequest) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.login(request: request))
    }
    
    func loginApple(request: SocialLoginRequest) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.loginApple(request: request))
    }

    func loginGoogle(request: SocialLoginRequest, idToken: String) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.loginGoogle(request: request, idToken: idToken))
    }

    func loginKakao(request: SocialLoginRequest, accessToken: String) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.loginKakao(request: request, accessToken: accessToken))
    }

    func loginLine(request: SocialLoginRequest) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.loginLine(request: request))
    }
    
    func signUp(request: SignUpRequest) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.signUp(request: request))
    }
    
    func findPassword(email: String) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.findPassword(request: ForgotPasswordRequest(email: email)))
    }
    
    func searchUser(nickname: String) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.searchUser(nickname: nickname))
    }
    
    func getMypage() -> AnyPublisher<Response, MoyaError> {
        #if AUTH_VERIFICATION_MOCK
        return selfMemberPublisher(.getMypage, as: MyPageResponse.self)
        #else
        return api.requestPublisher(.getMypage)
        #endif
    }
    
    func getMemberInfo() -> AnyPublisher<Response, MoyaError> {
        #if AUTH_VERIFICATION_MOCK
        return selfMemberPublisher(.getMemberInfo, as: GetMemberInfoResponse.self)
        #else
        return api.requestPublisher(.getMemberInfo)
        #endif
    }

    func updateContentPreference(request: UpdateContentPreferenceRequest) -> AnyPublisher<Response, MoyaError> {
        #if AUTH_VERIFICATION_MOCK
        let requestToken = UserDefaults.string(forKey: .token)
        let session = AuthVerificationMock.shared.session(for: requestToken)
        return api.requestPublisher(.updateContentPreference(request: request))
            .map { response in
                AuthVerificationMock.shared.updateContentPreference(from: response.data,
                                                                     statusCode: response.statusCode,
                                                                     requestToken: requestToken,
                                                                     session: session)
                return response
            }
            .eraseToAnyPublisher()
        #else
        return api.requestPublisher(.updateContentPreference(request: request))
        #endif
    }
    
    func getMemberCan() -> AnyPublisher<Response, MoyaError> {
        #if AUTH_VERIFICATION_MOCK
        return getMemberInfo()
        #else
        return api.requestPublisher(.getMemberInfo)
        #endif
    }
    
    func updateNotificationSettings(live: Bool? = nil, uploadContent: Bool? = nil, message: Bool? = nil, audition: Bool? = nil) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(
            .notification(
                request: UpdateNotificationSettingRequest(
                    live: live,
                    uploadContent: uploadContent,
                    message: message,
                    audition: audition
                )
            )
        )
    }
    
    func logout() -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.logout)
    }
    
    func logoutAllDevice() -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.logoutAllDevice)
    }
    
    func signOut(reason: String, password: String) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.signOut(request: SignOutRequest(reason: reason, password: password)))
    }
    
    func updatePushToken(pushToken: String) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.updatePushToken(request: PushTokenUpdateRequest(pushToken: pushToken)))
    }
    
    func creatorFollow(creatorId: Int, follow: Bool = true, notify: Bool = true) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.creatorFollow(request: CreatorFollowRequest(creatorId: creatorId, isNotify: notify, isActive: follow)))
    }
    
    func creatorUnFollow(creatorId: Int) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.creatorUnFollow(request: CreatorFollowRequest(creatorId: creatorId)))
    }
    
    func getBlockedMemberIdList() -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.getBlockedMemberIdList)
    }
    
    func getBlockedMemberList(page: Int, size: Int) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.getBlockedMemberList(page: page, size: size))
    }
    
    func memberBlock(userId: Int) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.memberBlock(request: MemberBlockRequest(blockMemberId: userId)))
    }
    
    func memberUnBlock(userId: Int) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.memberUnBlock(request: MemberBlockRequest(blockMemberId: userId)))
    }
    
    func getMyProfile() -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.getMyProfile)
    }
    
    func profileImageUpdate(parameter: MultipartFormData) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.profileImageUpdate(parameter: parameter))
    }
    
    func profileUpdate(request: ProfileUpdateRequest) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.profileUpdate(request: request))
    }
    
    func getChangeNicknamePrice() -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.getChangeNicknamePrice)
    }
    
    func checkNickname(nickname: String) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.checkNickname(nickname: nickname))
    }
    
    func changeNickname(request: ProfileUpdateRequest) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.changeNickname(request: request))
    }
    
    func updateIdfa(request: IdfaUpdateRequest) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.updateIdfa(request: request))
    }
    
    func updateMarketingInfo(request: MarketingInfoUpdateRequest) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.updateMarketingInfo(request: request))
    }
    
    func getMemberProfile(memberId: Int) -> AnyPublisher<Response, MoyaError> {
        return api.requestPublisher(.getMemberProfile(memberId: memberId))
    }

    #if AUTH_VERIFICATION_MOCK
    private func selfMemberPublisher<Member: Decodable>(_ target: UserApi, as type: Member.Type) -> AnyPublisher<Response, MoyaError> {
        let requestToken = UserDefaults.string(forKey: .token)
        let session = AuthVerificationMock.shared.session(for: requestToken)
        return api.requestPublisher(target)
            .map { response in
                let data = AuthVerificationMock.shared.overlayMemberResponse(response.data,
                                                                             statusCode: response.statusCode,
                                                                             requestToken: requestToken,
                                                                             session: session,
                                                                             as: type)
                guard data != response.data else { return response }
                return Response(statusCode: response.statusCode, data: data,
                                request: response.request, response: response.response)
            }
            .eraseToAnyPublisher()
    }
    #endif
}