jsdw_ios/QuickLocation/Service/UserService.swift

//
//  UserService.swift
//  QuickLocation
//
//  Created by 八条 on 2026/5/28.
//

import RxSwift
import Moya

struct UserService {
    static let disposeBag = DisposeBag()

    /// 登录
    /// - Parameters:
    ///     - type: weixin、phone、apple、onekey、device、alipay
    ///     - bind：1绑定 2解绑 为空是登录
    static func login(type: String,
                      bind: String = "",
                      data: [String: Any]) -> Observable<UserLoginRespons> {
        return APIProvider.request(token: UserAPI.login(type: type,
                                                        bind: bind,
                                                        data: data).multiTarget,
                                   handle: false)
            .map(UserLoginRespons.self)
            .asObservable()
    }

    /// 用户信息
    static func userInfo() -> Observable<UserConfigResponse> {
        let api = UserAPI.userInfo.multiTarget
        return APIProvider.request(token: api)
            .map(UserConfigResponse.self)
            .asObservable()
    }

    /// 用户当前状态
    static func userStatus() -> Observable<UserStatusResponse> {
        let api = UserAPI.userStatus.multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(UserStatusResponse.self)
            .asObservable()
    }

    /// 指定圈子成员的今日手机使用数据
    static func phoneUsageToday(userId: String, groupKey: String) -> Observable<PhoneUsageTodayResponse> {
        let api = UserAPI.phoneUsageToday(userId: userId, groupKey: groupKey).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(PhoneUsageTodayResponse.self)
            .asObservable()
    }

    /// 指定圈子成员的 APP 周期使用报告
    static func phoneUsagePeriod(
        userId: String,
        groupKey: String,
        period: String
    ) -> Observable<PhoneUsagePeriodResponse> {
        let api = UserAPI.phoneUsagePeriod(userId: userId, groupKey: groupKey, period: period).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(PhoneUsagePeriodResponse.self)
            .asObservable()
    }

    /// 指定成员某日历史行程
    static func phoneUsageTrips(userId: String, date: Int64) -> Observable<PhoneUsageTripsResponse> {
        let api = UserAPI.phoneUsageTrips(userId: userId, date: date).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(PhoneUsageTripsResponse.self)
            .asObservable()
    }

    /// 查询应用图标 id（不存在时 fileId 为空）
    static func queryPhoneUsageIcon(package: String) -> Observable<PhoneUsageIconResponse> {
        let api = UserAPI.queryPhoneUsageIcon(package: package).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(PhoneUsageIconResponse.self)
            .asObservable()
    }

    /// 登记应用图标
    static func savePhoneUsageIcon(package: String, icon: String) -> Observable<PhoneUsageIconResponse> {
        let api = UserAPI.savePhoneUsageIcon(package: package, icon: icon).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(PhoneUsageIconResponse.self)
            .asObservable()
    }

    /// 上报本机配对应用
    static func phoneLockApp(token: String, icon: String) -> Observable<ResponseModel> {
        let api = UserAPI.phoneLockApp(token: token, icon: icon).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(ResponseModel.self)
            .asObservable()
    }

    /// 成员可锁应用列表
    static func phoneLockApps(userId: String, groupKey: String) -> Observable<PhoneLockAppsResponse> {
        let api = UserAPI.phoneLockApps(userId: userId, groupKey: groupKey).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(PhoneLockAppsResponse.self)
            .asObservable()
    }

    /// 删除本机配对应用；空 token 数组表示全部删除
    static func phoneLockAppsDelete(
        os: String = "ios",
        tokens: [String]
    ) -> Observable<ResponseModel> {
        let api = UserAPI.phoneLockAppsDelete(os: os, tokens: tokens).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(ResponseModel.self)
            .asObservable()
    }

    /// 锁定成员应用
    static func phoneLock(
        os: String,
        groupKey: String,
        userId: String,
        tokens: [String],
        iconIndex: Int,
        message: String
    ) -> Observable<ResponseModel> {
        let api = UserAPI.phoneLock(
            os: os,
            groupKey: groupKey,
            userId: userId,
            tokens: tokens,
            iconIndex: iconIndex,
            message: message
        ).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(ResponseModel.self)
            .asObservable()
    }

    /// 查询自己是否被锁
    static func phoneLocked(os: String = "ios") -> Observable<PhoneLockedResponse> {
        let api = UserAPI.phoneLocked(os: os).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(PhoneLockedResponse.self)
            .asObservable()
    }

    /// 发起解锁请求
    static func requestPhoneUnlock(
        os: String,
        groupKey: String,
        tokens: [String]
    ) -> Observable<ResponseModel> {
        let api = UserAPI.requestPhoneUnlock(os: os, groupKey: groupKey, tokens: tokens).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(ResponseModel.self)
            .asObservable()
    }

    /// 拉取解锁请求列表
    static func phoneUnlockRequests(os: String = "ios") -> Observable<PhoneUnlockRequestsResponse> {
        let api = UserAPI.phoneUnlockRequests(os: os).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(PhoneUnlockRequestsResponse.self)
            .asObservable()
    }

    /// 解锁
    static func phoneUnlock(
        os: String,
        groupKey: String,
        userId: String,
        tokens: [String]
    ) -> Observable<ResponseModel> {
        let api = UserAPI.phoneUnlock(os: os, groupKey: groupKey, userId: userId, tokens: tokens).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(ResponseModel.self)
            .asObservable()
    }

    /// 查询本机离线期间是否允许解锁
    static func phoneUnlockAllow(os: String = "ios") -> Observable<PhoneUnlockAllowResponse> {
        let api = UserAPI.phoneUnlockAllow(os: os).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(PhoneUnlockAllowResponse.self)
            .asObservable()
    }

    /// 确认本机已执行解锁
    static func phoneUnlockAllowConfirm(
        os: String = "ios",
        groupKey: String,
        userId: String,
        tokens: [String]
    ) -> Observable<ResponseModel> {
        let api = UserAPI.phoneUnlockAllowConfirm(
            os: os,
            groupKey: groupKey,
            userId: userId,
            tokens: tokens
        ).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    static func imToken() -> Observable<ResponseModel> {
        let api = UserAPI.imToken.multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 签到信息
    static func signInInfo() -> Observable<SignInInfoResponse> {
        let api = UserAPI.signInInfo.multiTarget
        return APIProvider.request(token: api)
            .map(SignInInfoResponse.self)
            .asObservable()
    }

    /// 签到
    static func signIn(latitude: Double, longitude: Double, address: String) -> Observable<ResponseModel> {
        let api = UserAPI.signIn(latitude: latitude, longitude: longitude, address: address).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }

    /// 更换手机
    static func changePhone(timestamp: String, phone: String, code: String) -> Observable<ResponseModel> {
        let api = UserAPI.changePhone(timestamp: timestamp, phone: phone, code: code).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 设置头像（预设序号或上传后的图片 URL）
    static func setHeadPic(headPic: String) -> Observable<ResponseModel> {
        let api = UserAPI.setHeadPic(headPic: headPic).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }

    static func changeAvater(url: String) -> Observable<ResponseModel> {
        let api = UserAPI.changeAvater(url: url).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 设置昵称
    static func setNickName(nick: String) -> Observable<ResponseModel> {
        let api = UserAPI.setNickName(nick: nick).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }

    /// 设置心情
    static func setMood(moodIndex: Int) -> Observable<ResponseModel> {
        let api = UserAPI.setMood(moodIndex: moodIndex).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 设置性别
    static func setGender(sex: Int) -> Observable<ResponseModel> {
        let api = UserAPI.setGender(sex: sex).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 紧急联系人列表
    static func emergencyContactList() -> Observable<EmergencyContactListResponse> {
        let api = UserAPI.emergencyContact(opType: "get", requestData: [:]).multiTarget
        return APIProvider.request(token: api)
            .map(EmergencyContactListResponse.self)
            .asObservable()
    }
    
    /// 添加紧急联系人
    static func emergencyContactAdd(requestData: [String: Any]) -> Observable<ResponseModel> {
        let api = UserAPI.emergencyContact(opType: "add", requestData: requestData).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 删除紧急联系人
    static func emergencyContactDelete(id: String = "", phone: String) -> Observable<ResponseModel> {
        var requestData: [String: Any] = ["phone": phone]
        if !id.isEmpty {
            requestData["id"] = id
        }
        let api = UserAPI.emergencyContact(opType: "del", requestData: requestData).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 删除账号
    static func deleteAccount() -> Observable<ResponseModel> {
        let api = UserAPI.deleteAccount.multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 退出登录
    static func logout() -> Observable<ResponseModel> {
        let api = UserAPI.logout.multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 发送快捷消息、表情
    /// - Parameters:
    ///     - target_uid: 对方的user_id
    ///     - group_key：频道的key
    ///     - emote_idx：表情符号的下标
    static func sendEmote(emoteIdx: Int, groupKey: String, targetUid: String) -> Observable<ResponseModel> {
        let api = UserAPI.sendEmote(emoteIdx: emoteIdx, groupKey: groupKey, targetUid: targetUid).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 首页公告
    static func notice() -> Observable<ResponseModel> {
        let api = UserAPI.notice.multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 查看关注用户列表
    static func followList() -> Observable<ViewedListResponse> {
        let api = UserAPI.followList.multiTarget
        return APIProvider.request(token: api)
            .map(ViewedListResponse.self)
            .asObservable()
    }
    
    /// 设置气泡
    /// - Parameters:
    ///     - enable:
    ///     - keep_time：
    static func setBubble(enable: Bool, keep_time: Int) -> Observable<ResponseModel> {
        let api = UserAPI.bubble(enable: enable, keep_time: keep_time).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }
    
    /// 紧急人邮箱
    static func setEmail(email: String) -> Observable<ResponseModel> {
        let api = UserAPI.setEmail(email: email).multiTarget
        return APIProvider.request(token: api)
            .map(ResponseModel.self)
            .asObservable()
    }

    /// 关系列表
    static func relations() -> Observable<RelationListResponse> {
        let api = UserAPI.relations.multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(RelationListResponse.self)
            .asObservable()
    }

    static func mailboxList(page: Int, size: Int = 10) -> Observable<MailboxListResponse> {
        let api = UserAPI.mailboxList(page: page, size: size).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(MailboxListResponse.self)
            .asObservable()
    }

    static func mailboxDetail(id: Int) -> Observable<MailboxDetailResponse> {
        let api = UserAPI.mailboxOperate(opType: "info", id: id).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(MailboxDetailResponse.self)
            .asObservable()
    }

    static func clearMailbox() -> Observable<ResponseModel> {
        let api = UserAPI.mailboxOperate(opType: "alldelete", id: nil).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(ResponseModel.self)
            .asObservable()
    }

    /// 提交意见反馈
    static func feedback(
        type: String,
        content: String,
        contact: String,
        images: [String]
    ) -> Observable<ResponseModel> {
        let api = UserAPI.feedback(
            type: type,
            content: content,
            contact: contact,
            images: images
        ).multiTarget
        return APIProvider.request(token: api, handle: false)
            .map(ResponseModel.self)
            .asObservable()
    }
}