import unittest

from ca_core.crypto.zenroom_service_client import (
    ZenroomServiceClient,
    ZenroomServiceError,
)


class TestZenroomServiceClient(unittest.TestCase):
    def setUp(self):
        self.client = ZenroomServiceClient()

    def test_1_generate_keypair(self):
        result = self.client.generate_keypair("Alice")

        self.assertEqual(result["my_name"], "Alice")
        self.assertIn("keyring", result)
        self.assertIsInstance(result["keyring"], dict)
        self.assertIn("ecdh", result["keyring"])
        self.assertIsInstance(result["keyring"]["ecdh"], str)
        self.assertTrue(result["keyring"]["ecdh"])
        self.assertEqual(result["private_key"], result["keyring"]["ecdh"])

    def test_2_generate_public_key(self):
        keypair = self.client.generate_keypair("Alice")
        public_key = self.client.generate_public_key(keypair["keyring"])

        self.assertIsInstance(public_key, str)
        self.assertTrue(public_key)

    def test_3_symmetric_encrypt(self):
        result = self.client.symmetric_encrypt(
            header="test-header",
            message="hello symmetric crypto",
            shared_key="correct horse battery staple",
        )

        self.assertIsInstance(result, dict)
        self.assertIn("checksum", result)
        self.assertIn("header", result)
        self.assertIn("iv", result)
        self.assertIn("text", result)

        self.assertIsInstance(result["checksum"], str)
        self.assertIsInstance(result["header"], str)
        self.assertIsInstance(result["iv"], str)
        self.assertIsInstance(result["text"], str)

        self.assertTrue(result["checksum"])
        self.assertTrue(result["header"])
        self.assertTrue(result["iv"])
        self.assertTrue(result["text"])

    def test_4_symmetric_decrypt(self):
        plaintext = "hello symmetric crypto"
        password = "correct horse battery staple"

        encrypted = self.client.symmetric_encrypt(
            header="test-header",
            message=plaintext,
            shared_key=password,
        )

        decrypted = self.client.symmetric_decrypt(
            secret_message=encrypted,
            shared_key=password,
        )

        self.assertEqual(decrypted, plaintext)

    def test_5_asymmetric_encrypt(self):
        alice = self.client.generate_keypair("Alice")
        bob = self.client.generate_keypair("Bob")
        bob_public_key = self.client.generate_public_key(bob["keyring"])

        result = self.client.asymmetric_encrypt(
            receiver_public_key=bob_public_key,
            sender_keyring=alice["keyring"],
            header="asym-header",
            message="hello bob",
        )

        self.assertIsInstance(result, dict)
        self.assertIn("checksum", result)
        self.assertIn("header", result)
        self.assertIn("iv", result)
        self.assertIn("text", result)

        self.assertIsInstance(result["checksum"], str)
        self.assertIsInstance(result["header"], str)
        self.assertIsInstance(result["iv"], str)
        self.assertIsInstance(result["text"], str)

        self.assertTrue(result["checksum"])
        self.assertTrue(result["header"])
        self.assertTrue(result["iv"])
        self.assertTrue(result["text"])

    def test_6_asymmetric_decrypt(self):
        alice = self.client.generate_keypair("Alice")
        bob = self.client.generate_keypair("Bob")

        alice_public_key = self.client.generate_public_key(alice["keyring"])
        bob_public_key = self.client.generate_public_key(bob["keyring"])

        encrypted = self.client.asymmetric_encrypt(
            receiver_public_key=bob_public_key,
            sender_keyring=alice["keyring"],
            header="asym-header",
            message="hello bob",
        )

        decrypted = self.client.asymmetric_decrypt(
            sender_public_key=alice_public_key,
            receiver_keyring=bob["keyring"],
            secret=encrypted,
        )

        self.assertIsInstance(decrypted, dict)
        self.assertEqual(decrypted["header"], "asym-header")
        self.assertEqual(decrypted["text"], "hello bob")

    def test_7_sign_objects(self):
        alice = self.client.generate_keypair("Alice")

        result = self.client.sign_objects(
            objects={"myMessage": "hello signed world"},
            signer_keyring=alice["keyring"],
        )

        self.assertIsInstance(result, dict)
        self.assertIn("myMessage", result)
        self.assertIn("myMessage.signature", result)
        self.assertEqual(result["myMessage"], "hello signed world")

        signature = result["myMessage.signature"]
        self.assertIsInstance(signature, dict)
        self.assertIn("r", signature)
        self.assertIn("s", signature)
        self.assertIsInstance(signature["r"], str)
        self.assertIsInstance(signature["s"], str)
        self.assertTrue(signature["r"])
        self.assertTrue(signature["s"])

    def test_8_verify_signature(self):
        alice = self.client.generate_keypair("Alice")
        alice_public_key = self.client.generate_public_key(alice["keyring"])

        signed = self.client.sign_objects(
            objects={"myMessage": "hello signed world"},
            signer_keyring=alice["keyring"],
        )

        verified = self.client.verify_signature(
            message_field="myMessage",
            message_value=signed["myMessage"],
            signature=signed["myMessage.signature"],
            signer_public_key=alice_public_key,
        )

        self.assertTrue(verified)

    def test_9_verify_signature_rejects_modified_message(self):
        alice = self.client.generate_keypair("Alice")
        alice_public_key = self.client.generate_public_key(alice["keyring"])

        signed = self.client.sign_objects(
            objects={"myMessage": "hello"},
            signer_keyring=alice["keyring"],
        )

        with self.assertRaises(ZenroomServiceError):
            self.client.verify_signature(
                message_field="myMessage",
                message_value="tampered",
                signature=signed["myMessage.signature"],
                signer_public_key=alice_public_key,
            )


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