//
//  UserConfigResponse.swift
//  QuickLocation
//
//  Created by 八条 on 2026/5/26.
//

import Foundation
import ObjectMapper

private let kUserStatusTransformInt64 = TransformOf<Int64, Any>(fromJSON: { value in
    switch value {
    case let value as Int64:
        return value
    case let value as Int:
        return Int64(value)
    case let value as Double:
        return Int64(value)
    case let value as String:
        return Int64(value)
    default:
        return nil
    }
}, toJSON: { value in
    value
})

class UserConfigResponse: BaseModelProtocol {
    var code: String?
    
    var message: String?
    
    var model: UserConfigModel?
    
    required init?(map: Map) {
        
    }
    
    func mapping(map: Map) {
        code <- map["code"]
        message <- map["message"]
        model <- map["data"]
    }
}

class UserLoginRespons: BaseModelProtocol {
    var code: String?
    
    var message: String?
    
    var model: UserConfigModel?
    
    required init?(map: Map) {
        
    }
    
    func mapping(map: Map) {
        code <- map["code"]
        message <- map["message"]
        model <- map["data"]
    }
}

struct UserStatusResponse: BaseModelProtocol {
    var code: String?
    var message: String?
    var model: UserStatusModel?

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        code <- (map["code"], kIntTransformStr)
        message <- map["message"]
        model <- map["data"]
    }
}

struct UserStatusModel: Mappable {
    var status: Int = 0
    var mood: Int = 0
    var bubbleTime: Int64 = 0

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        status <- (map["status"], kStrTransformInt)
        mood <- (map["mood"], kStrTransformInt)
        bubbleTime <- (map["end_time"], kUserStatusTransformInt64)
        if bubbleTime == 0 {
            bubbleTime <- (map["bubble_time"], kUserStatusTransformInt64)
        }
    }

    var bubbleEndDate: Date? {
        guard bubbleTime > 0 else { return nil }
        let seconds = bubbleTime >= 100_000_000_000
            ? TimeInterval(bubbleTime) / 1000
            : TimeInterval(bubbleTime)
        return Date(timeIntervalSince1970: seconds)
    }
}

struct PhoneUsageTripsResponse: BaseModelProtocol {
    var code: String?
    var message: String?
    var success: Bool = false
    var date: String = ""
    var userId: String = ""
    var trips: [ScheduleRecordModel] = []

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        code <- (map["code"], kIntTransformStr)
        message <- map["message"]
        success <- map["success"]
        date <- map["data.date"]
        userId <- (map["data.user_id"], kIntTransformStr)
        trips <- map["data.trips"]
    }
}

struct PhoneUsageTodayResponse: BaseModelProtocol {
    var code: String?
    var message: String?
    var model: PhoneUsageTodayModel?

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        code <- (map["code"], kIntTransformStr)
        message <- map["message"]
        model <- map["data"]
    }
}

struct PhoneUsageTodayModel: Mappable {
    var appCount: Int?
    var phoneInfo: PhoneUsageInfoModel?
    var stayPoints: [PhoneUsageStayPointModel] = []
    var topApps: [PhoneUsageAppModel] = []

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        appCount <- (map["app_count"], kStrTransformInt)
        phoneInfo <- map["phone_info"]
        stayPoints <- map["stay_points"]
        topApps <- map["top_apps"]
    }
}

struct PhoneUsageAppModel: Mappable {
    var package: String = ""
    var appName: String = ""
    var appIcon: String = ""
    var usageTime: Int = 0
    var percentage: Int?

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        package <- (map["package"], kIntTransformStr)
        appName <- (map["app_name"], kIntTransformStr)
        appIcon <- (map["app_icon"], kIntTransformStr)
        if appIcon.isEmpty {
            appIcon <- (map["icon"], kIntTransformStr)
        }
        usageTime <- (map["usage_time"], kStrTransformInt)
        percentage <- (map["percentage"], kStrTransformInt)
    }
}

struct PhoneUsagePeriodResponse: BaseModelProtocol {
    var code: String?
    var message: String?
    var model: PhoneUsagePeriodModel?

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        code <- (map["code"], kIntTransformStr)
        message <- map["message"]
        model <- map["data"]
    }
}

struct PhoneUsagePeriodModel: Mappable {
    var favoriteApps: [PhoneUsageAppModel] = []
    var totalUsageTime: Int = 0
    var useTime: String = ""
    var unlockCount: String = ""

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        favoriteApps <- map["favorite_apps"]
        totalUsageTime <- (map["total_usage_time"], kStrTransformInt)
        useTime <- (map["use_time"], kIntTransformStr)
        unlockCount <- (map["unlock_count"], kIntTransformStr)
    }
}

struct PhoneUsageReportResponse: BaseModelProtocol {
    var code: String?
    var message: String?
    var model: PhoneUsageReportModel?

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        code <- (map["code"], kIntTransformStr)
        message <- map["message"]
        model <- map["data"]
    }
}

struct PhoneUsageReportModel: Mappable {
    var phoneInfo: PhoneUsageInfoModel?
    var brand: String = ""
    var brandIcon: String = ""
    var screenUseTimes: [PhoneUsageReportDayModel] = []
    var appUseCounts: [PhoneUsageReportDayModel] = []

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        phoneInfo <- map["phone_info"]
        brand <- (map["brand"], kIntTransformStr)
        brandIcon <- (map["brand_icon"], kIntTransformStr)
        screenUseTimes <- map["screen_use_times"]
        appUseCounts <- map["app_use_counts"]
    }
}

struct PhoneUsageReportDayModel: Mappable {
    var day: String = ""
    var useTime: Int?
    var count: Int?

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        day <- (map["day"], kIntTransformStr)
        useTime <- (map["use_time"], kStrTransformInt)
        count <- (map["count"], kStrTransformInt)
    }
}

struct PhoneUsageInfoModel: Mappable {
    var brand: String = ""
    var model: String = ""
    var memoryTotal: String = ""
    var memoryUsed: String = ""
    var battery: String = ""
    var network: String = ""
    var brightness: String = ""
    var volume: String = ""
    var weather: String = ""
    var useTime: String = ""
    var unlockCount: String = ""

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        brand <- (map["brand"], kIntTransformStr)
        model <- (map["model"], kIntTransformStr)
        memoryTotal <- (map["memory_total"], kIntTransformStr)
        memoryUsed <- (map["memory_used"], kIntTransformStr)
        battery <- (map["battery"], kIntTransformStr)
        network <- (map["network"], kIntTransformStr)
        brightness <- (map["brightness"], kIntTransformStr)
        volume <- (map["volume"], kIntTransformStr)
        weather <- (map["weather"], kIntTransformStr)
        useTime <- (map["use_time"], kIntTransformStr)
        unlockCount <- (map["unlock_count"], kIntTransformStr)
    }
}

struct PhoneUsageStayPointModel: Mappable {
    var id: String = ""
    var userId: String = ""
    var location: PhoneUsageStayLocationModel?
    var startTime: String = ""
    var endTime: String = ""
    var durationMinutes: Int?
    var visitCount: Int?
    var address: PhoneUsageStayAddressModel?
    var createdAt: String = ""

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        id <- (map["id"], kIntTransformStr)
        userId <- (map["user_id"], kIntTransformStr)
        location <- map["location"]
        startTime <- (map["start_time"], kIntTransformStr)
        endTime <- (map["end_time"], kIntTransformStr)
        durationMinutes <- (map["duration_minutes"], kStrTransformInt)
        visitCount <- (map["visit_count"], kStrTransformInt)
        address <- map["address"]
        createdAt <- (map["created_at"], kIntTransformStr)
    }

    var startDate: Date? {
        Self.date(from: startTime)
    }

    var resolvedDurationMinutes: Int? {
        if let durationMinutes, durationMinutes >= 0 {
            return durationMinutes
        }
        guard let startDate = Self.date(from: startTime),
              let endDate = Self.date(from: endTime),
              endDate >= startDate else { return nil }
        return Int(endDate.timeIntervalSince(startDate) / 60)
    }

    private static func date(from value: String) -> Date? {
        guard !value.isEmpty else { return nil }
        let fractional = ISO8601DateFormatter()
        fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        if let date = fractional.date(from: value) {
            return date
        }
        let standard = ISO8601DateFormatter()
        standard.formatOptions = [.withInternetDateTime]
        return standard.date(from: value)
    }
}

struct PhoneUsageStayLocationModel: Mappable {
    var latitude: Double = 0
    var longitude: Double = 0

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        latitude <- map["latitude"]
        longitude <- map["longitude"]
    }
}

struct PhoneUsageStayAddressModel: Mappable {
    var formattedAddress: String = ""
    var country: String = ""
    var province: String = ""
    var city: String = ""
    var district: String = ""
    var street: String = ""

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        formattedAddress <- (map["formatted_address"], kIntTransformStr)
        country <- (map["country"], kIntTransformStr)
        province <- (map["province"], kIntTransformStr)
        city <- (map["city"], kIntTransformStr)
        district <- (map["district"], kIntTransformStr)
        street <- (map["street"], kIntTransformStr)
    }
}

struct PhoneUsageIconResponse: BaseModelProtocol {
    var code: String?
    var message: String?
    var fileId: String = ""

    static var empty: PhoneUsageIconResponse {
        Mapper<PhoneUsageIconResponse>().map(JSON: [:])!
    }

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        code <- (map["code"], kIntTransformStr)
        message <- map["message"]
        if message == nil {
            message <- map["msg"]
        }
        fileId <- (map["data.file_id"], kIntTransformStr)
        if fileId.isEmpty {
            fileId <- (map["data.icon"], kIntTransformStr)
        }
        if fileId.isEmpty {
            fileId <- (map["data.id"], kIntTransformStr)
        }
        if fileId.isEmpty {
            fileId <- (map["data"], kIntTransformStr)
        }
    }
}

struct PhoneLockAppsResponse: BaseModelProtocol {
    var code: String?
    var message: String?
    var model: PhoneLockAppsModel?
    var fromUser: String = ""

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        code <- (map["code"], kIntTransformStr)
        message <- map["message"]
        if message == nil {
            message <- map["msg"]
        }
        model <- map["data"]
        fromUser <- (map["data.from_user"], kIntTransformStr)
        if fromUser.isEmpty {
            fromUser <- (map["from_user"], kIntTransformStr)
        }
    }

    var resolvedFromUser: String {
        let modelFromUser = model?.resolvedFromUser ?? ""
        return modelFromUser.isEmpty ? fromUser.trimmed : modelFromUser
    }
}

struct PhoneLockAppsModel: Mappable {
    var apps: [PhoneLockAppItem] = []
    var fromUser: String = ""

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        apps <- map["apps"]
        fromUser <- (map["from_user"], kIntTransformStr)
    }

    var resolvedFromUser: String {
        let value = fromUser.trimmed
        if !value.isEmpty { return value }
        return apps.first { $0.locked && !$0.fromUser.trimmed.isEmpty }?.fromUser.trimmed ?? ""
    }
}

struct PhoneLockAppItem: Mappable {
    var os: String = ""
    var token: String = ""
    var icon: String = ""
    var locked: Bool = false
    var fromUser: String = ""

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        os <- (map["os"], kIntTransformStr)
        token <- (map["token"], kIntTransformStr)
        icon <- (map["icon"], kIntTransformStr)
        fromUser <- (map["from_user"], kIntTransformStr)
        locked = Self.parseBool(map.JSON["locked"]) || Self.parseBool(map.JSON["is_locked"])
    }

    private static func parseBool(_ value: Any?) -> Bool {
        switch value {
        case let flag as Bool:
            return flag
        case let number as Int:
            return number != 0
        case let number as Double:
            return number != 0
        case let text as String:
            let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
            return trimmed == "1" || trimmed == "true" || trimmed == "yes"
        default:
            return false
        }
    }
}

struct PhoneLockedResponse: BaseModelProtocol {
    var code: String?
    var message: String?
    var model: PhoneLockedModel?

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        code <- (map["code"], kIntTransformStr)
        message <- map["message"]
        if message == nil {
            message <- map["msg"]
        }
        model <- map["data"]
    }
}

struct PhoneUnlockAllowResponse: BaseModelProtocol {
    var code: String?
    var message: String?
    var model: PhoneLockedModel?

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        code <- (map["code"], kIntTransformStr)
        message <- map["message"]
        if message == nil {
            message <- map["msg"]
        }
        model <- map["data"]
    }
}

struct PhoneLockedModel: Mappable {
    var locks: [PhoneLockRecord] = []

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        locks <- map["locks"]
    }
}

struct PhoneLockRecord: Mappable {
    var id: String = ""
    var fromUser: String = ""
    var groupKey: String = ""
    var groupName: String = ""
    var userId: String = ""
    var tokens: [String] = []
    var os: String = ""
    var iconIndex: Int = 0
    var message: String = ""
    var lockTime: Int64 = 0
    var appIcon: String = ""

    init() {}

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        id <- (map["id"], kIntTransformStr)
        fromUser <- (map["from_user"], kIntTransformStr)
        groupKey <- (map["group_key"], kIntTransformStr)
        groupName <- (map["group_name"], kIntTransformStr)
        userId <- (map["user_id"], kIntTransformStr)
        os <- (map["os"], kIntTransformStr)
        iconIndex <- (map["icon_index"], kStrTransformInt)
        message <- (map["message"], kIntTransformStr)
        lockTime <- (map["lock_time"], kUserStatusTransformInt64)
        appIcon <- (map["app_icon"], kIntTransformStr)
        tokens = Self.parseTokens(map.JSON["token"])
    }

    var displayGroupName: String {
        let name = groupName.trimmingCharacters(in: .whitespacesAndNewlines)
        return name.isEmpty ? "圈子" : name
    }

    var lockStartDate: Date {
        guard lockTime > 0 else { return Date() }
        let seconds = lockTime >= 100_000_000_000
            ? TimeInterval(lockTime) / 1000
            : TimeInterval(lockTime)
        return Date(timeIntervalSince1970: seconds)
    }

    var wallpaperImageName: String {
        let index = min(max(iconIndex, 0), 6) + 1
        return "LockDistract/lock_icon_\(index)"
    }

    static func parseTokens(_ value: Any?) -> [String] {
        if let array = value as? [Any] {
            return array.compactMap(transformStr).filter { !$0.isEmpty }
        }
        if let text = transformStr(value), !text.isEmpty {
            return [text]
        }
        return []
    }
}

enum PhoneLockSession {
    static var currentLocks: [PhoneLockRecord] = []
}

struct PhoneUnlockRequestsResponse: BaseModelProtocol {
    var code: String?
    var message: String?
    var list: [PhoneUnlockRequestItem] = []

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        code <- (map["code"], kIntTransformStr)
        message <- map["message"]
        if message == nil {
            message <- map["msg"]
        }
        list <- map["data.requests"]
        if list.isEmpty {
            list <- map["data.list"]
        }
        if list.isEmpty {
            list <- map["data.locks"]
        }
        if list.isEmpty {
            list <- map["data"]
        }
    }
}

struct PhoneUnlockRequestItem: Mappable {
    var fromUser: String = ""
    var userId: String = ""
    var toUser: String = ""
    var groupKey: String = ""
    var os: String = ""
    var nickName: String = ""
    var headPic: String = ""
    var tokens: [String] = []
    var lockTime: Int64 = 0
    var requestUnlock: Int = 0

    init?(map: Map) {}

    mutating func mapping(map: Map) {
        fromUser <- (map["from_user"], kIntTransformStr)
        userId <- (map["user_id"], kIntTransformStr)
        toUser <- (map["to_user"], kIntTransformStr)
        groupKey <- (map["group_key"], kIntTransformStr)
        os <- (map["os"], kIntTransformStr)
        nickName <- (map["nick_name"], kIntTransformStr)
        if nickName.isEmpty {
            nickName <- (map["name"], kIntTransformStr)
        }
        headPic <- (map["head_pic"], kFlexString)
        if headPic.isEmpty {
            headPic <- (map["avater"], kFlexString)
        }
        lockTime <- (map["lock_time"], kUserStatusTransformInt64)
        requestUnlock <- (map["request_unlock"], kStrTransformInt)
        tokens = PhoneLockRecord.parseTokens(map.JSON["token"])
    }

    var targetUserId: String {
        let to = toUser.trimmingCharacters(in: .whitespacesAndNewlines)
        if !to.isEmpty { return to }
        let from = fromUser.trimmingCharacters(in: .whitespacesAndNewlines)
        if !from.isEmpty { return from }
        return userId.trimmingCharacters(in: .whitespacesAndNewlines)
    }

    var lockStartDate: Date {
        guard lockTime > 0 else { return Date() }
        let seconds = lockTime >= 100_000_000_000
            ? TimeInterval(lockTime) / 1000
            : TimeInterval(lockTime)
        return Date(timeIntervalSince1970: seconds)
    }
}