import hashlib
import json
import unittest

from core.device_id import is_valid_egid
from core.device_profile import (
    DeviceProfile,
    DeviceProfileGenerator,
    load_device_profile,
    save_device_profile,
)


class DeviceProfileTests(unittest.TestCase):
    def test_generator_creates_consistent_local_identity(self):
        profile = DeviceProfileGenerator(seed=1234).new_profile()

        self.assertEqual(len(profile.android_id), 16)
        self.assertEqual(profile.android_id, profile.android_id.lower())
        int(profile.android_id, 16)
        self.assertEqual(profile.o_did, f"ANDROID_{profile.android_id}")
        self.assertTrue(profile.local_did.startswith("ANDROID_"))
        self.assertEqual(profile.did, profile.local_did)

        expected_rdid = hashlib.md5(profile.g_rdi2.encode("utf-8")).hexdigest()[16:32]
        self.assertEqual(profile.rdid, f"ANDROID_{expected_rdid}")
        self.assertTrue(is_valid_egid(profile.egid))
        self.assertIn(profile.egid, profile.runtime_hints.sted_cache_json)
        self.assertTrue(profile.runtime_hints.persisted_cache_m)

    def test_profile_persistence_roundtrip(self):
        import tempfile
        from pathlib import Path

        with tempfile.TemporaryDirectory() as tmp:
            path = Path(tmp) / "device.json"
            profile = DeviceProfileGenerator(seed=5678).new_profile()

            save_device_profile(profile, path)
            loaded = load_device_profile(path)

            self.assertEqual(loaded, profile)
            self.assertEqual(
                json.loads(path.read_text(encoding="utf-8"))["android_id"],
                profile.android_id,
            )

    def test_apply_cloud_identity_updates_only_server_fields(self):
        profile = DeviceProfileGenerator(seed=9012).new_profile()
        old_android_id = profile.android_id
        old_o_did = profile.o_did
        old_rdid = profile.rdid

        profile.apply_cloud_identity(
            did="ANDROID_e8dfd2f16b618053",
            cdid_tag=2,
            egid="DFP68CA12B5D3C714E4439D5E255B197DA809D63CB77139F1420A763F53FE718",
        )

        self.assertEqual(profile.did, "ANDROID_e8dfd2f16b618053")
        self.assertEqual(profile.cdid_tag, 2)
        self.assertEqual(
            profile.egid,
            "DFP68CA12B5D3C714E4439D5E255B197DA809D63CB77139F1420A763F53FE718",
        )
        self.assertEqual(profile.android_id, old_android_id)
        self.assertEqual(profile.o_did, old_o_did)
        self.assertEqual(profile.rdid, old_rdid)

    def test_env_export_contains_expected_identity_keys(self):
        profile = DeviceProfileGenerator(seed=3456).new_profile()
        env_text = profile.to_env()

        self.assertIn(f"KS_ANDROID_ID={profile.android_id}", env_text)
        self.assertIn(f"KS_DID={profile.did}", env_text)
        self.assertIn(f"KS_ODID={profile.o_did}", env_text)
        self.assertIn(f"KS_RDID={profile.rdid}", env_text)
        self.assertIn(f"KS_LOCAL_DID={profile.local_did}", env_text)
        self.assertIn(f"KS_EGID={profile.egid}", env_text)

    def test_generated_profile_contains_stable_hardware_fields(self):
        profile = DeviceProfileGenerator(seed=4567).new_profile()

        self.assertEqual(profile.package_name, "com.kuaishou.nebula")
        self.assertEqual(profile.app_version, "14.5.50.11631")
        self.assertEqual(profile.android_release, "16")
        self.assertTrue(profile.manufacturer)
        self.assertTrue(profile.brand)
        self.assertTrue(profile.model)
        self.assertGreater(profile.screen_width, 0)
        self.assertGreater(profile.screen_height, 0)
        self.assertGreater(profile.total_memory_mb, 0)
        self.assertTrue(profile.board_platform)
        self.assertTrue(profile.soc_name)
        self.assertGreater(profile.max_memory, 0)
        self.assertTrue(profile.device_bit)
        self.assertIn(profile.isp, {"CUCC", "CTCC", "CMCC"})
        self.assertIn(f"KS_APPVER={profile.app_version}", profile.to_env())
        self.assertIn(f"KS_SOC_NAME={profile.soc_name}", profile.to_env())

    def test_generated_profile_contains_runtime_hints(self):
        profile = DeviceProfileGenerator(seed=4567).new_profile()
        hints = profile.runtime_hints

        self.assertTrue(hints.k4_native)
        self.assertGreater(hints.storage_available_bytes, 0)
        self.assertEqual(len(hints.k51_native), 16)
        self.assertEqual(len(hints.k84_native), 16)
        self.assertTrue(hints.boot_id)
        self.assertTrue(hints.grdi)
        self.assertIn("::", hints.grdi)
        self.assertTrue(hints.keeper_seed)
        self.assertTrue(hints.du)
        self.assertTrue(hints.sted_cache_json)
        self.assertIn(profile.egid, hints.sted_cache_json)
        self.assertTrue(hints.persisted_cache_m)
        self.assertTrue(hints.manus)
        self.assertTrue(hints.gaid)
        self.assertIn("KS_K105=", profile.to_env())

    def test_runtime_hints_persist_roundtrip(self):
        import tempfile
        from pathlib import Path

        with tempfile.TemporaryDirectory() as tmp:
            path = Path(tmp) / "device.json"
            profile = DeviceProfileGenerator(seed=5678).new_profile()

            save_device_profile(profile, path)
            loaded = load_device_profile(path)

            self.assertEqual(loaded.runtime_hints, profile.runtime_hints)

    def test_profile_validation_rejects_invalid_identity_fields(self):
        cases = [
            ("android_id", "XYZ"),
            ("local_did", "BAD"),
            ("did", "BAD"),
            ("o_did", "BAD"),
            ("rdid", "BAD"),
            ("egid", "BAD"),
        ]
        for field, value in cases:
            with self.subTest(field=field):
                data = DeviceProfileGenerator(seed=7890).new_profile().to_dict()
                data[field] = value

                with self.assertRaises(ValueError):
                    DeviceProfile.from_dict(data)


if __name__ == "__main__":
    unittest.main()