from django.test import TestCase
from django.core.exceptions import ValidationError
from apps.domains.models import Domain, Organisation, Dataset
from apps.users.models import User
from uuid import uuid4


class DomainTestCase(TestCase):

    def setUp(self):
        self.domain1 = Domain.objects.create(name="Python", description="Python Programming")
        self.domain2 = Domain.objects.create(name="JavaScript", description="JavaScript Development")

    def test_domain_creation(self):
        self.assertEqual(self.domain1.name, "Python")
        self.assertEqual(self.domain2.name, "JavaScript")

    def test_domain_string_representation(self):
        self.assertEqual(str(self.domain1), "Python")
        self.assertEqual(str(self.domain2), "JavaScript")

    def test_domain_name_unique(self):
        with self.assertRaises(Exception):
            Domain.objects.create(name="Python", description="Duplicate")

    def test_domain_description_blank(self):
        domain = Domain.objects.create(name="Java")
        self.assertEqual(domain.description, "")

    def test_domain_description_optional(self):
        domain = Domain.objects.create(name="Rust", description="System Programming")
        self.assertIsNotNone(domain.description)

    def test_domain_uuid_generated(self):
        self.assertIsNotNone(self.domain1.uuid)
        self.assertIsNotNone(self.domain2.uuid)

    def test_domain_uuid_unique(self):
        uuid1 = self.domain1.uuid
        uuid2 = self.domain2.uuid
        self.assertNotEqual(uuid1, uuid2)

    def test_domain_uuid_immutable(self):
        original_uuid = self.domain1.uuid
        self.domain1.save()
        self.assertEqual(self.domain1.uuid, original_uuid)

    def test_domain_count(self):
        self.assertEqual(Domain.objects.count(), 2)

    def test_domain_filter_by_name(self):
        domain = Domain.objects.get(name="Python")
        self.assertEqual(domain.id, self.domain1.id)

    def test_domain_filter_by_uuid(self):
        domain = Domain.objects.get(uuid=self.domain1.uuid)
        self.assertEqual(domain.name, "Python")

    def test_domain_update_name(self):
        self.domain1.name = "Python3"
        self.domain1.save()
        updated = Domain.objects.get(id=self.domain1.id)
        self.assertEqual(updated.name, "Python3")

    def test_domain_update_description(self):
        self.domain1.description = "Advanced Python"
        self.domain1.save()
        updated = Domain.objects.get(id=self.domain1.id)
        self.assertEqual(updated.description, "Advanced Python")

    def test_domain_delete(self):
        domain_id = self.domain1.id
        self.domain1.delete()
        with self.assertRaises(Domain.DoesNotExist):
            Domain.objects.get(id=domain_id)

    def test_domain_all_fields(self):
        self.assertTrue(hasattr(self.domain1, 'name'))
        self.assertTrue(hasattr(self.domain1, 'uuid'))
        self.assertTrue(hasattr(self.domain1, 'description'))

    def test_domain_max_length_name(self):
        long_name = "a" * 255
        domain = Domain.objects.create(name=long_name)
        self.assertEqual(domain.name, long_name)

    def test_domain_default_description(self):
        domain = Domain.objects.create(name="Go")
        self.assertEqual(domain.description, "")


class OrganisationTestCase(TestCase):

    def setUp(self):
        self.user1 = User.objects.create_user(email_address="manager@test.com", password="pass123")
        self.user2 = User.objects.create_user(email_address="employee@test.com", password="pass123")
        self.domain = Domain.objects.create(name="Technology")
        # Organization model uses `owner` and `members`.
        self.org1 = Organisation.objects.create(
            name="TechCorp",
            owner=self.user1,
        )
        # add member and link domain
        self.org1.members.add(self.user2)
        self.domain.organization = self.org1
        self.domain.save()

    def test_organisation_creation(self):
        self.assertEqual(self.org1.name, "TechCorp")

    def test_organisation_string_representation(self):
        self.assertEqual(str(self.org1), "TechCorp")

    def test_organisation_name_unique(self):
        with self.assertRaises(Exception):
            Organisation.objects.create(
                name="TechCorp",
                owner=self.user1,
            )

    def test_organisation_manager_relationship(self):
        self.assertEqual(self.org1.owner, self.user1)

    def test_organisation_employee_relationship(self):
        self.assertTrue(self.org1.members.filter(pk=self.user2.pk).exists())

    def test_organisation_domain_relationship(self):
        self.assertTrue(self.org1.domains.filter(pk=self.domain.pk).exists())

    def test_organisation_uuid_generated(self):
        self.assertIsNotNone(self.org1.uuid)

    def test_organisation_timestamps(self):
        self.assertIsNotNone(self.org1.created_at)
        self.assertIsNotNone(self.org1.updated_at)

    def test_organisation_created_at_updated_at_close_on_creation(self):
        delta = abs((self.org1.created_at - self.org1.updated_at).total_seconds())
        self.assertLess(delta, 1)

    def test_organisation_update_changes_updated_at(self):
        original_updated = self.org1.updated_at
        import time
        time.sleep(0.1)
        self.org1.name = "TechCorp Updated"
        self.org1.save()
        self.assertGreater(self.org1.updated_at, original_updated)

    def test_organisation_count(self):
        self.assertEqual(Organisation.objects.count(), 1)

    def test_organisation_filter_by_name(self):
        org = Organisation.objects.get(name="TechCorp")
        self.assertEqual(org.id, self.org1.id)

    def test_organisation_filter_by_manager(self):
        orgs = Organisation.objects.filter(owner=self.user1)
        self.assertEqual(orgs.count(), 1)

    def test_organisation_delete_cascade(self):
        org_id = self.org1.id
        self.org1.delete()
        with self.assertRaises(Organisation.DoesNotExist):
            Organisation.objects.get(id=org_id)

    def test_organisation_update_name(self):
        self.org1.name = "NewTechCorp"
        self.org1.save()
        updated = Organisation.objects.get(id=self.org1.id)
        self.assertEqual(updated.name, "NewTechCorp")


class DatasetTestCase(TestCase):

    def setUp(self):
        self.user = User.objects.create_user(email_address="creator@test.com", password="pass123")
        self.domain = Domain.objects.create(name="ML")
        self.dataset1 = Dataset.objects.create(
            domain=self.domain,
            name="Training Data",
            description="Training dataset for ML",
            created_by=self.user
        )

    def test_dataset_creation(self):
        self.assertEqual(self.dataset1.name, "Training Data")

    def test_dataset_string_representation(self):
        self.assertEqual(str(self.dataset1), "Training Data (ML)")

    def test_dataset_domain_relationship(self):
        self.assertEqual(self.dataset1.domain, self.domain)

    def test_dataset_created_by_relationship(self):
        self.assertEqual(self.dataset1.created_by, self.user)

    def test_dataset_description_optional(self):
        dataset = Dataset.objects.create(
            domain=self.domain,
            name="Test Data",
            created_by=self.user
        )
        self.assertEqual(dataset.description, "")

    def test_dataset_uuid_generated(self):
        self.assertIsNotNone(self.dataset1.uuid)

    def test_dataset_timestamps(self):
        self.assertIsNotNone(self.dataset1.created_at)
        self.assertIsNotNone(self.dataset1.updated_at)

    def test_dataset_count(self):
        self.assertEqual(Dataset.objects.count(), 1)

    def test_dataset_filter_by_domain(self):
        datasets = Dataset.objects.filter(domain=self.domain)
        self.assertEqual(datasets.count(), 1)

    def test_dataset_filter_by_creator(self):
        datasets = Dataset.objects.filter(created_by=self.user)
        self.assertEqual(datasets.count(), 1)

    def test_dataset_filter_by_name(self):
        dataset = Dataset.objects.get(name="Training Data")
        self.assertEqual(dataset.id, self.dataset1.id)

    def test_dataset_update_description(self):
        self.dataset1.description = "Updated description"
        self.dataset1.save()
        updated = Dataset.objects.get(id=self.dataset1.id)
        self.assertEqual(updated.description, "Updated description")

    def test_dataset_delete(self):
        dataset_id = self.dataset1.id
        self.dataset1.delete()
        with self.assertRaises(Dataset.DoesNotExist):
            Dataset.objects.get(id=dataset_id)

    def test_dataset_multiple_per_domain(self):
        dataset2 = Dataset.objects.create(
            domain=self.domain,
            name="Test Data",
            created_by=self.user
        )
        datasets = Dataset.objects.filter(domain=self.domain)
        self.assertEqual(datasets.count(), 2)

    def test_dataset_multiple_per_creator(self):
        dataset2 = Dataset.objects.create(
            domain=self.domain,
            name="Test Data 2",
            created_by=self.user
        )
        datasets = Dataset.objects.filter(created_by=self.user)
        self.assertEqual(datasets.count(), 2)

    def test_dataset_cascade_on_domain_delete(self):
        dataset_id = self.dataset1.id
        self.domain.delete()
        with self.assertRaises(Dataset.DoesNotExist):
            Dataset.objects.get(id=dataset_id)

    def test_dataset_cascade_on_user_delete(self):
        dataset_id = self.dataset1.id
        self.user.delete()
        with self.assertRaises(Dataset.DoesNotExist):
            Dataset.objects.get(id=dataset_id)