//
//  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 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] = []

    init?(map: Map) {}

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

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)
    }
}