#!/usr/bin/env python3
"""
Unit tests for user management functionality
"""

import unittest
from unittest.mock import Mock, patch, MagicMock
import sys
import os

# Add parent directory to path to import modules
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))

from user_management import UserManager, PermissionManager, GranteeType, PermissionType
from sigma_api_client import SigmaAPIClient, SigmaConfig

class TestUserManager(unittest.TestCase):
    """Test cases for UserManager"""
    
    def setUp(self):
        """Set up test fixtures"""
        self.mock_client = Mock(spec=SigmaAPIClient)
        self.user_manager = UserManager(self.mock_client)
    
    def test_init(self):
        """Test UserManager initialization"""
        self.assertEqual(self.user_manager.api, self.mock_client)
    
    def test_list_members_success(self):
        """Test successful member listing"""
        # Mock API response
        mock_response = {
            'entries': [
                {'memberId': '1', 'email': 'user1@test.com', 'firstName': 'User', 'lastName': 'One'},
                {'memberId': '2', 'email': 'user2@test.com', 'firstName': 'User', 'lastName': 'Two'}
            ]
        }
        self.mock_client.get.return_value = mock_response
        
        # Test
        result = self.user_manager.list_members()
        
        # Assertions
        self.assertEqual(len(result), 2)
        self.assertEqual(result[0]['email'], 'user1@test.com')
        self.mock_client.get.assert_called_once_with('/v2/members', params={'limit': 50})
    
    def test_list_members_with_custom_limit(self):
        """Test member listing with custom limit"""
        mock_response = {'entries': []}
        self.mock_client.get.return_value = mock_response
        
        self.user_manager.list_members(limit=100)
        
        self.mock_client.get.assert_called_once_with('/v2/members', params={'limit': 100})
    
    def test_get_member_by_email_found(self):
        """Test finding member by email"""
        # Mock members list
        mock_members = [
            {'memberId': '1', 'email': 'user1@test.com', 'firstName': 'User', 'lastName': 'One'},
            {'memberId': '2', 'email': 'user2@test.com', 'firstName': 'User', 'lastName': 'Two'}
        ]
        
        with patch.object(self.user_manager, 'list_members', return_value=mock_members):
            result = self.user_manager.get_member_by_email('user2@test.com')
        
        self.assertIsNotNone(result)
        self.assertEqual(result['memberId'], '2')
        self.assertEqual(result['email'], 'user2@test.com')
    
    def test_get_member_by_email_not_found(self):
        """Test member not found by email"""
        mock_members = [
            {'memberId': '1', 'email': 'user1@test.com', 'firstName': 'User', 'lastName': 'One'}
        ]
        
        with patch.object(self.user_manager, 'list_members', return_value=mock_members):
            result = self.user_manager.get_member_by_email('nonexistent@test.com')
        
        self.assertIsNone(result)
    
    def test_get_member_by_email_case_insensitive(self):
        """Test case insensitive email search"""
        mock_members = [
            {'memberId': '1', 'email': 'User1@Test.Com', 'firstName': 'User', 'lastName': 'One'}
        ]
        
        with patch.object(self.user_manager, 'list_members', return_value=mock_members):
            result = self.user_manager.get_member_by_email('user1@test.com')
        
        self.assertIsNotNone(result)
        self.assertEqual(result['memberId'], '1')
    
    def test_create_member_success(self):
        """Test successful member creation"""
        mock_response = {
            'memberId': 'new_member_id',
            'email': 'newuser@test.com',
            'firstName': 'New',
            'lastName': 'User',
            'accountType': 'viewer'
        }
        self.mock_client.post.return_value = mock_response
        
        result = self.user_manager.create_member(
            email='newuser@test.com',
            first_name='New',
            last_name='User',
            account_type='viewer'
        )
        
        self.assertEqual(result['email'], 'newuser@test.com')
        self.mock_client.post.assert_called_once()
        call_args = self.mock_client.post.call_args
        self.assertEqual(call_args[0][0], '/v2/members')
        self.assertEqual(call_args[0][1]['email'], 'newuser@test.com')
    
    def test_update_member_account_type(self):
        """Test member account type update"""
        mock_response = {'memberId': 'test_id', 'accountType': 'admin'}
        self.mock_client.patch.return_value = mock_response
        
        result = self.user_manager.update_member_account_type('test_id', 'admin')
        
        self.assertEqual(result['accountType'], 'admin')
        self.mock_client.patch.assert_called_once_with('/v2/members/test_id', {'accountType': 'admin'})
    
    def test_deactivate_member(self):
        """Test member deactivation"""
        self.mock_client.delete.return_value = True
        
        result = self.user_manager.deactivate_member('test_id')
        
        self.assertTrue(result)
        self.mock_client.delete.assert_called_once_with('/v2/members/test_id')

class TestPermissionManager(unittest.TestCase):
    """Test cases for PermissionManager"""
    
    def setUp(self):
        """Set up test fixtures"""
        self.mock_client = Mock(spec=SigmaAPIClient)
        self.permission_manager = PermissionManager(self.mock_client)
    
    def test_list_grants_success(self):
        """Test successful grants listing"""
        mock_response = {
            'entries': [
                {'grantId': '1', 'resource': 'workbook1', 'permission': 'view'},
                {'grantId': '2', 'resource': 'workbook2', 'permission': 'edit'}
            ]
        }
        self.mock_client.get.return_value = mock_response
        
        result = self.permission_manager.list_grants()
        
        self.assertEqual(len(result), 2)
        self.assertEqual(result[0]['grantId'], '1')
        self.mock_client.get.assert_called_once_with('/v2/grants', params={'limit': 50})
    
    def test_grant_workbook_access(self):
        """Test granting workbook access"""
        mock_response = {
            'grantId': 'new_grant_id',
            'resource': 'workbook_id',
            'grantee': 'user_id',
            'permission': 'view'
        }
        self.mock_client.post.return_value = mock_response
        
        result = self.permission_manager.grant_workbook_access(
            workbook_id='workbook_id',
            grantee_id='user_id',
            grantee_type=GranteeType.USER,
            permission=PermissionType.VIEW
        )
        
        self.assertEqual(result['grantId'], 'new_grant_id')
        self.mock_client.post.assert_called_once()
        call_args = self.mock_client.post.call_args
        expected_data = {
            'resource': 'workbook_id',
            'grantee': 'user_id',
            'granteeType': 'user',
            'permission': 'view'
        }
        self.assertEqual(call_args[0][1], expected_data)
    
    def test_revoke_access(self):
        """Test access revocation"""
        self.mock_client.delete.return_value = True
        
        result = self.permission_manager.revoke_access('grant_id')
        
        self.assertTrue(result)
        self.mock_client.delete.assert_called_once_with('/v2/grants/grant_id')
    
    def test_find_grants_for_user(self):
        """Test finding grants for specific user"""
        mock_grants = [
            {'grantId': '1', 'grantee': 'user1', 'resource': 'resource1'},
            {'grantId': '2', 'grantee': 'user2', 'resource': 'resource2'},
            {'grantId': '3', 'grantee': 'user1', 'resource': 'resource3'}
        ]
        
        with patch.object(self.permission_manager, 'list_grants', return_value=mock_grants):
            result = self.permission_manager.find_grants_for_user('user1')
        
        self.assertEqual(len(result), 2)
        self.assertEqual(result[0]['grantId'], '1')
        self.assertEqual(result[1]['grantId'], '3')
    
    def test_find_grants_for_resource(self):
        """Test finding grants for specific resource"""
        mock_grants = [
            {'grantId': '1', 'grantee': 'user1', 'resource': 'resource1'},
            {'grantId': '2', 'grantee': 'user2', 'resource': 'resource2'},
            {'grantId': '3', 'grantee': 'user3', 'resource': 'resource1'}
        ]
        
        with patch.object(self.permission_manager, 'list_grants', return_value=mock_grants):
            result = self.permission_manager.find_grants_for_resource('resource1')
        
        self.assertEqual(len(result), 2)
        self.assertEqual(result[0]['grantId'], '1')
        self.assertEqual(result[1]['grantId'], '3')

class TestEnums(unittest.TestCase):
    """Test cases for enum values"""
    
    def test_grantee_type_enum(self):
        """Test GranteeType enum values"""
        self.assertEqual(GranteeType.USER.value, "user")
        self.assertEqual(GranteeType.TEAM.value, "team")
    
    def test_permission_type_enum(self):
        """Test PermissionType enum values"""
        self.assertEqual(PermissionType.VIEW.value, "view")
        self.assertEqual(PermissionType.EXPLORE.value, "explore")
        self.assertEqual(PermissionType.EDIT.value, "edit")

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