from django.contrib.auth import get_user_model
from django.test import Client, TestCase
from django.urls import reverse

from accounts.models import (
    RbacPermission,
    RbacRole,
    RbacRolePermission,
    UserRbacRole,
    UserRole,
)
from accounts.rbac import is_permission_bypass, user_has_perm
from accounts.rbac_catalog import iter_permission_defs

User = get_user_model()


class RbacSeedTests(TestCase):
    def test_permissions_seeded(self):
        expected = {d['codename'] for d in iter_permission_defs()}
        self.assertGreaterEqual(RbacPermission.objects.count(), len(expected))
        for codename in expected:
            self.assertTrue(
                RbacPermission.objects.filter(codename=codename).exists(),
                f'missing {codename}',
            )
        # Administration / Users modules must not appear in catalog
        self.assertFalse(RbacPermission.objects.filter(module='administration').exists())
        self.assertFalse(RbacPermission.objects.filter(module='users').exists())


class RbacBypassAndGatingTests(TestCase):
    def setUp(self):
        self.super = User.objects.create_superuser(
            username='super@example.com',
            email='super@example.com',
            password='password123',
        )
        self.admin = User.objects.create_user(
            username='admin@example.com',
            email='admin@example.com',
            password='password123',
            is_staff=True,
        )
        UserRole.objects.create(user=self.admin, role=UserRole.Role.ADMIN)
        self.role = RbacRole.objects.create(name='Ops Viewer', is_active=True)
        view_zones = RbacPermission.objects.get(codename='zones.view')
        RbacRolePermission.objects.create(role=self.role, permission=view_zones)

        self.panel_user = User.objects.create_user(
            username='ops@example.com',
            email='ops@example.com',
            password='password123',
            is_staff=True,
        )
        UserRole.objects.create(user=self.panel_user, role=UserRole.Role.USER)
        UserRbacRole.objects.create(user=self.panel_user, role=self.role)

        self.no_role_user = User.objects.create_user(
            username='norole@example.com',
            email='norole@example.com',
            password='password123',
            is_staff=True,
        )
        UserRole.objects.create(user=self.no_role_user, role=UserRole.Role.USER)

    def test_superadmin_and_admin_bypass(self):
        self.assertTrue(is_permission_bypass(self.super))
        self.assertTrue(is_permission_bypass(self.admin))
        self.assertTrue(user_has_perm(self.super, 'zones.delete'))
        self.assertTrue(user_has_perm(self.admin, 'zones.delete'))
        self.assertFalse(is_permission_bypass(self.panel_user))

    def test_user_gated_by_role(self):
        self.assertTrue(user_has_perm(self.panel_user, 'zones.view'))
        self.assertFalse(user_has_perm(self.panel_user, 'zones.delete'))
        self.assertFalse(user_has_perm(self.no_role_user, 'zones.view'))
        self.assertFalse(user_has_perm(self.no_role_user, 'dashboard.view'))

    def test_panel_user_denied_without_perm(self):
        client = Client()
        client.login(username='ops@example.com', password='password123')
        # Has zones.view
        self.assertEqual(client.get(reverse('core:zones')).status_code, 200)
        # Lacks zones.add
        self.assertEqual(client.get(reverse('core:zones_new')).status_code, 403)
        # Lacks shippers.view
        self.assertEqual(client.get(reverse('core:shipper')).status_code, 403)


class PanelUsersAccessTests(TestCase):
    def setUp(self):
        self.super = User.objects.create_superuser(
            username='super2@example.com',
            email='super2@example.com',
            password='password123',
        )
        self.admin = User.objects.create_user(
            username='admin2@example.com',
            email='admin2@example.com',
            password='password123',
            is_staff=True,
        )
        UserRole.objects.create(user=self.admin, role=UserRole.Role.ADMIN)
        self.role = RbacRole.objects.create(name='Basic', is_active=True)
        self.panel = User.objects.create_user(
            username='panel@example.com',
            email='panel@example.com',
            password='password123',
            is_staff=True,
        )
        UserRole.objects.create(user=self.panel, role=UserRole.Role.USER)
        UserRbacRole.objects.create(user=self.panel, role=self.role)

    def test_admin_can_create_panel_user_with_role(self):
        client = Client()
        client.login(username='admin2@example.com', password='password123')
        resp = client.post(reverse('core:panel_users_new'), {
            'email': 'newops@example.com',
            'password': 'password123',
            'first_name': 'New',
            'last_name': 'Ops',
            'phone': '',
            'rbac_role': str(self.role.id),
            'is_active': 'on',
        })
        self.assertEqual(resp.status_code, 302)
        created = User.objects.get(username='newops@example.com')
        self.assertTrue(created.is_staff)
        self.assertFalse(created.is_superuser)
        self.assertEqual(created.role.role, UserRole.Role.USER)
        self.assertEqual(created.rbac_assignment.role_id, self.role.id)

    def test_superadmin_view_only_cannot_create(self):
        client = Client()
        client.login(username='super2@example.com', password='password123')
        self.assertEqual(client.get(reverse('core:panel_users')).status_code, 200)
        resp = client.post(reverse('core:panel_users_new'), {
            'email': 'blocked@example.com',
            'password': 'password123',
            'rbac_role': str(self.role.id),
            'is_active': 'on',
        })
        self.assertEqual(resp.status_code, 403)
        self.assertFalse(User.objects.filter(username='blocked@example.com').exists())

    def test_superadmin_cannot_delete_panel_user(self):
        client = Client()
        client.login(username='super2@example.com', password='password123')
        resp = client.post(reverse('core:panel_users_delete', args=[self.panel.id]))
        self.assertEqual(resp.status_code, 403)
        self.assertTrue(User.objects.filter(pk=self.panel.id).exists())

    def test_panel_user_cannot_access_roles_or_users_module(self):
        client = Client()
        client.login(username='panel@example.com', password='password123')
        self.assertEqual(client.get(reverse('core:roles')).status_code, 403)
        self.assertEqual(client.get(reverse('core:panel_users')).status_code, 403)
        self.assertEqual(client.get(reverse('core:users')).status_code, 403)

    def test_admin_can_manage_roles(self):
        client = Client()
        client.login(username='admin2@example.com', password='password123')
        self.assertEqual(client.get(reverse('core:roles')).status_code, 200)
        perm = RbacPermission.objects.get(codename='dashboard.view')
        resp = client.post(reverse('core:roles_new'), {
            'name': 'Dashboard Only',
            'is_active': 'on',
            'permissions': [str(perm.id)],
        })
        self.assertEqual(resp.status_code, 302)
        role = RbacRole.objects.get(name='Dashboard Only')
        self.assertTrue(role.permissions.filter(codename='dashboard.view').exists())
