package com.enterprise.mdm.device

import android.Manifest
import android.app.ActivityManager
import android.content.Context
import android.content.pm.PackageManager
import android.net.wifi.WifiManager
import android.os.BatteryManager
import android.os.Build
import android.os.Environment
import android.os.StatFs
import android.provider.Settings
import android.telephony.TelephonyManager
import androidx.core.content.ContextCompat
import com.enterprise.mdm.data.api.RegisterDeviceRequest
import com.enterprise.mdm.data.api.SyncRequest

class DeviceInfoCollector(private val context: Context) {

    @Suppress("HardwareIds")
    fun deviceUid(): String =
        Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID) ?: "unknown"

    fun buildRegister(isOwner: Boolean) = RegisterDeviceRequest(
        device_uid = deviceUid(),
        device_name = "${Build.MANUFACTURER} ${Build.MODEL}",
        manufacturer = Build.MANUFACTURER,
        brand = Build.BRAND,
        model = Build.MODEL,
        android_version = "Android ${Build.VERSION.RELEASE} (API ${Build.VERSION.SDK_INT})",
        security_patch = Build.VERSION.SECURITY_PATCH,
        is_device_owner = isOwner
    )

    fun buildSync(): SyncRequest {
        val bm = context.getSystemService(Context.BATTERY_SERVICE) as BatteryManager
        val battery = bm.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
        val charging = bm.isCharging

        val am = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
        val mem = ActivityManager.MemoryInfo().also { am.getMemoryInfo(it) }

        val stat = StatFs(Environment.getDataDirectory().path)
        val storageTotal = stat.blockCountLong * stat.blockSizeLong
        val storageAvail = stat.availableBlocksLong * stat.blockSizeLong

        val tm = context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
        val carrier = try { tm.networkOperatorName } catch (e: Exception) { null }
        val networkType = networkTypeName(tm)

        val wifi = context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
        val ssid = try { wifi.connectionInfo.ssid } catch (e: Exception) { null }

        return SyncRequest(
            battery_level = battery,
            charging = charging,
            ram_total = mem.totalMem,
            ram_available = mem.availMem,
            storage_total = storageTotal,
            storage_available = storageAvail,
            cpu = Build.SUPPORTED_ABIS.joinToString(),
            carrier = carrier,
            sim_info = simInfo(tm),
            network_type = networkType,
            wifi_ssid = ssid
        )
    }

    private fun simInfo(tm: TelephonyManager): String? = try {
        if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_PHONE_STATE)
            == PackageManager.PERMISSION_GRANTED) tm.simOperatorName else null
    } catch (e: Exception) { null }

    private fun networkTypeName(tm: TelephonyManager): String = try {
        when (tm.dataNetworkType) {
            TelephonyManager.NETWORK_TYPE_LTE -> "4G LTE"
            TelephonyManager.NETWORK_TYPE_NR -> "5G"
            TelephonyManager.NETWORK_TYPE_HSPA, TelephonyManager.NETWORK_TYPE_HSPAP -> "3G"
            TelephonyManager.NETWORK_TYPE_EDGE, TelephonyManager.NETWORK_TYPE_GPRS -> "2G"
            else -> "Mobile/WiFi"
        }
    } catch (e: Exception) { "Unknown" }
}