class GDPRPrinciples:
    """Principiile GDPR asa cum se aplica sistemelor AI."""
 
    principles = {
        'lawfulness_fairness_transparency': {
            'requirement': 'Procesarea trebuie sa aiba baza juridica si sa fie corecta si transparenta',
            'ai_implications': [
                'Documenteaza baza juridica pentru utilizarea datelor de antrenament AI',
                'Explica procesul de luare a deciziilor AI persoanelor vizate',
                'Divulga utilizarea AI in deciziile automatizate',
                'Asigura-te ca rezultatele AI sunt corecte si nediscriminatorii'
            ]
        },
        'purpose_limitation': {
            'requirement': 'Datele colectate doar pentru scopuri specificate',
            'ai_implications': [
                'Modelele AI ar trebui sa foloseasca date doar pentru scopurile declarate',
                'Reutilizarea datelor de antrenament necesita o noua baza juridica',
                'Rezultatele modelului limitate la scopul original',
                'Documenteaza scopul pentru fiecare activitate de procesare AI'
            ]
        },
        'data_minimisation': {
            'requirement': 'Proceseaza doar datele necesare pentru scop',
            'ai_implications': [
                'Minimizeaza datele de antrenament la ceea ce este necesar',
                'Elimina caracteristicile inutile din modele',
                'Implementeaza selectia caracteristicilor pentru confidentialitate',
                'Revizuire periodica a cerintelor de date'
            ]
        },
        'accuracy': {
            'requirement': 'Datele personale trebuie sa fie exacte si actualizate',
            'ai_implications': [
                'Modelele AI trebuie sa mentina acuratetea predictiilor',
                'Datele de antrenament trebuie sa fie exacte',
                'Procese pentru corectarea datelor inexacte',
                'Reantrenare periodica a modelului cu date actualizate'
            ]
        },
        'storage_limitation': {
            'requirement': 'Pastreaza datele doar atat cat este necesar',
            'ai_implications': [
                'Defineste perioade de retentie pentru datele de antrenament',
                'Implementeaza proceduri de stergere a datelor de antrenament',
                'Ia in considerare cerintele de model unlearning',
                'Documenteaza justificarea retentiei'
            ]
        },
        'integrity_confidentiality': {
            'requirement': 'Securitate adecvata pentru datele personale',
            'ai_implications': [
                'Securizeaza datele de antrenament si ponderile modelului',
                'Protejeaza impotriva atacurilor adversariale',
                'Previne extragerea datelor de antrenament din modele',
                'Cripteaza datele in repaus si in tranzit'
            ]
        },
        'accountability': {
            'requirement': 'Demonstreaza conformitatea',
            'ai_implications': [
                'Documenteaza activitatile de procesare AI',
                'Mentine registre ale deciziilor de dezvoltare AI',
                'Implementeaza un cadru de guvernanta AI',
                'Audituri periodice de conformitate'
            ]
        }
    }

from enum import Enum
from dataclasses import dataclass
from typing import List, Optional
 
class LawfulBasis(Enum):
    CONSENT = "consent"
    CONTRACT = "contract"
    LEGAL_OBLIGATION = "legal_obligation"
    VITAL_INTERESTS = "vital_interests"
    PUBLIC_TASK = "public_task"
    LEGITIMATE_INTERESTS = "legitimate_interests"
 
@dataclass
class AIProcessingActivity:
    """Documenteaza activitatea de procesare AI pentru conformitatea GDPR."""
 
    activity_id: str
    purpose: str
    description: str
    data_categories: List[str]
    special_categories: List[str]  # Article 9 data
    lawful_basis: LawfulBasis
    lawful_basis_justification: str
    data_subjects: List[str]
    retention_period: str
    third_party_sharing: Optional[List[str]]
    automated_decision_making: bool
    safeguards: List[str]
 
    def to_ropa_entry(self) -> dict:
        """Genereaza intrare in Registrul Activitatilor de Procesare."""
        return {
            'activity_id': self.activity_id,
            'purpose': self.purpose,
            'lawful_basis': self.lawful_basis.value,
            'data_categories': self.data_categories,
            'special_categories': self.special_categories,
            'data_subjects': self.data_subjects,
            'retention': self.retention_period,
            'recipients': self.third_party_sharing,
            'automated_decisions': self.automated_decision_making,
            'safeguards': self.safeguards
        }
 
 
class LegitimateInterestsAssessment:
    """Efectueaza Evaluarea Interesului Legitim pentru procesarea AI."""
 
    def assess(self, processing: AIProcessingActivity) -> dict:
        """Efectueaza testul LIA in trei parti."""
 
        assessment = {
            'processing_activity': processing.activity_id,
            'assessment_date': datetime.utcnow().isoformat(),
            'tests': {}
        }
 
        # Test 1: Purpose test
        assessment['tests']['purpose'] = self._purpose_test(processing)
 
        # Test 2: Necessity test
        assessment['tests']['necessity'] = self._necessity_test(processing)
 
        # Test 3: Balancing test
        assessment['tests']['balancing'] = self._balancing_test(processing)
 
        # Overall result
        all_passed = all(
            t['passed'] for t in assessment['tests'].values()
        )
        assessment['legitimate_interests_established'] = all_passed
 
        return assessment
 
    def _purpose_test(self, processing: AIProcessingActivity) -> dict:
        """Evalueaza daca exista un interes legitim."""
        return {
            'question': 'Exista un interes legitim in spatele procesarii?',
            'considerations': [
                'Scopul este legal?',
                'Interesul este real si prezent (nu speculativ)?',
                'Este suficient de specific si clar articulat?'
            ],
            'documentation': processing.lawful_basis_justification,
            'passed': bool(processing.lawful_basis_justification)
        }
 
    def _necessity_test(self, processing: AIProcessingActivity) -> dict:
        """Evalueaza daca procesarea este necesara pentru interes."""
        return {
            'question': 'Procesarea este necesara pentru interes?',
            'considerations': [
                'Exista o modalitate mai putin intruziva de a atinge scopul?',
                'Procesarea este proportionata?',
                'Ai putea obtine acelasi rezultat cu mai putine date?'
            ],
            'alternatives_considered': True,  # Document alternatives
            'passed': True  # Based on documented analysis
        }
 
    def _balancing_test(self, processing: AIProcessingActivity) -> dict:
        """Echilibreaza interesele cu drepturile persoanelor vizate."""
        return {
            'question': 'Interesele prevaleaza asupra drepturilor persoanei vizate?',
            'factors_in_favor': [
                'Nevoia de business pentru procesarea AI',
                'Beneficii pentru persoanele vizate',
                'Beneficii publice mai largi'
            ],
            'factors_against': [
                'Impactul asupra persoanelor vizate',
                'Asteptarile rezonabile ale persoanelor vizate',
                'Natura datelor procesate'
            ],
            'safeguards': processing.safeguards,
            'passed': len(processing.safeguards) > 0
        }

from abc import ABC, abstractmethod
from datetime import datetime, timedelta
 
class DataSubjectRightsHandler:
    """Gestioneaza drepturile persoanelor vizate GDPR pentru sistemele AI."""
 
    def __init__(self, config: dict):
        self.response_deadline_days = 30
        self.request_log = []
 
    def handle_request(self, request: dict) -> dict:
        """Proceseaza o cerere de drepturi a persoanei vizate."""
 
        request_id = str(uuid.uuid4())
        request_type = request['type']
        data_subject_id = request['data_subject_id']
 
        # Log the request
        self._log_request(request_id, request)
 
        # Route to appropriate handler
        handlers = {
            'access': self._handle_access_request,
            'rectification': self._handle_rectification_request,
            'erasure': self._handle_erasure_request,
            'restriction': self._handle_restriction_request,
            'portability': self._handle_portability_request,
            'objection': self._handle_objection_request,
            'automated_decision': self._handle_automated_decision_request
        }
 
        handler = handlers.get(request_type)
        if not handler:
            return {'error': 'Unknown request type'}
 
        result = handler(data_subject_id, request)
 
        # Calculate deadline
        result['request_id'] = request_id
        result['deadline'] = (
            datetime.utcnow() + timedelta(days=self.response_deadline_days)
        ).isoformat()
 
        return result
 
    def _handle_access_request(self, data_subject_id: str,
                               request: dict) -> dict:
        """Articolul 15: Dreptul de acces."""
 
        # Gather all personal data
        personal_data = self._collect_personal_data(data_subject_id)
 
        # Include AI-specific information
        ai_data = {
            'training_data_used': self._check_training_data_inclusion(data_subject_id),
            'ai_profiles': self._get_ai_profiles(data_subject_id),
            'automated_decisions': self._get_automated_decisions(data_subject_id),
            'profiling_logic': self._get_profiling_explanation(data_subject_id)
        }
 
        return {
            'status': 'completed',
            'personal_data': personal_data,
            'ai_related_data': ai_data,
            'processing_purposes': self._get_processing_purposes(data_subject_id),
            'recipients': self._get_data_recipients(data_subject_id),
            'retention_periods': self._get_retention_info(),
            'source_of_data': self._get_data_sources(data_subject_id),
            'safeguards_for_transfers': self._get_transfer_safeguards()
        }
 
    def _handle_erasure_request(self, data_subject_id: str,
                                request: dict) -> dict:
        """Articolul 17: Dreptul la stergere (Dreptul de a fi uitat)."""
 
        # Check if erasure is applicable
        erasure_check = self._check_erasure_eligibility(data_subject_id)
 
        if not erasure_check['eligible']:
            return {
                'status': 'denied',
                'reason': erasure_check['reason'],
                'legal_basis': erasure_check['legal_basis']
            }
 
        # Perform erasure
        erasure_actions = []
 
        # 1. Delete from operational systems
        erasure_actions.append(self._delete_from_systems(data_subject_id))
 
        # 2. Handle AI-specific erasure
        if request.get('include_ai_data', True):
            # Remove from training datasets
            erasure_actions.append(
                self._remove_from_training_data(data_subject_id)
            )
 
            # Consider model unlearning (if technically feasible)
            if self._model_unlearning_feasible():
                erasure_actions.append(
                    self._trigger_model_unlearning(data_subject_id)
                )
            else:
                # Document why unlearning isn't feasible
                erasure_actions.append({
                    'action': 'model_unlearning_not_feasible',
                    'reason': 'Technical limitations',
                    'alternative_measures': [
                        'Datele marcate ca sterse',
                        'Modelul programat pentru reantrenare',
                        'Filtrare la inferenta implementata'
                    ]
                })
 
        # 3. Notify third parties
        if request.get('notify_third_parties', True):
            erasure_actions.append(
                self._notify_third_parties(data_subject_id, 'erasure')
            )
 
        return {
            'status': 'completed',
            'actions_taken': erasure_actions,
            'timestamp': datetime.utcnow().isoformat()
        }
 
    def _handle_automated_decision_request(self, data_subject_id: str,
                                          request: dict) -> dict:
        """Articolul 22: Drepturi legate de luarea automata a deciziilor."""
 
        request_subtype = request.get('subtype', 'information')
 
        if request_subtype == 'information':
            # Provide meaningful information about the logic
            return {
                'status': 'completed',
                'decision_id': request.get('decision_id'),
                'meaningful_information': self._explain_automated_decision(
                    data_subject_id, request.get('decision_id')
                ),
                'significance': self._describe_decision_significance(
                    request.get('decision_id')
                ),
                'consequences': self._describe_decision_consequences(
                    request.get('decision_id')
                )
            }
 
        elif request_subtype == 'human_intervention':
            # Request human review of automated decision
            return self._request_human_review(
                data_subject_id, request.get('decision_id')
            )
 
        elif request_subtype == 'contest':
            # Data subject wishes to contest the decision
            return self._initiate_decision_review(
                data_subject_id,
                request.get('decision_id'),
                request.get('grounds_for_contest')
            )
 
    def _explain_automated_decision(self, data_subject_id: str,
                                   decision_id: str) -> dict:
        """Ofera explicatie semnificativa a deciziei automatizate."""
 
        decision = self._get_decision(decision_id)
 
        return {
            'decision_type': decision['type'],
            'decision_date': decision['timestamp'],
            'outcome': decision['outcome'],
            'explanation': {
                'factors_considered': decision['factors'],
                'factor_weights': 'Clasificare aproximativa a importantei furnizata',
                'main_factors': decision['top_factors'],
                'logic_summary': decision['explanation_text'],
                'model_type': decision['model_type'],
                'accuracy_metrics': decision.get('model_accuracy')
            },
            'your_data_used': decision['input_data_summary'],
            'comparison_context': decision.get('percentile_context')
        }

class AutomatedDecisionMakingCompliance:
    """Asigura conformitatea cu Articolul 22 pentru deciziile automatizate AI."""
 
    def __init__(self, config: dict):
        self.adm_register = {}
        self.human_reviewers = config.get('human_reviewers', [])
 
    def register_adm_system(self, system: dict) -> str:
        """Inregistreaza un sistem de luare automata a deciziilor."""
 
        system_id = str(uuid.uuid4())
 
        adm_entry = {
            'system_id': system_id,
            'name': system['name'],
            'purpose': system['purpose'],
            'decision_types': system['decision_types'],
            'legal_basis': system['legal_basis'],
            'produces_legal_effects': system.get('produces_legal_effects', False),
            'significantly_affects': system.get('significantly_affects', False),
            'special_category_data': system.get('special_category_data', False),
            'safeguards': [],
            'registered_at': datetime.utcnow().isoformat()
        }
 
        # Determine required safeguards based on Article 22
        if adm_entry['produces_legal_effects'] or adm_entry['significantly_affects']:
            adm_entry['article_22_applies'] = True
            adm_entry['required_safeguards'] = self._determine_required_safeguards(adm_entry)
        else:
            adm_entry['article_22_applies'] = False
 
        self.adm_register[system_id] = adm_entry
        return system_id
 
    def _determine_required_safeguards(self, adm_entry: dict) -> List[dict]:
        """Determina masurile de protectie necesare pentru deciziile conform Articolului 22."""
 
        safeguards = [
            {
                'requirement': 'human_intervention',
                'description': 'Dreptul de a obtine interventie umana',
                'implementation': 'Proces de revizuire umana necesar'
            },
            {
                'requirement': 'express_view',
                'description': 'Dreptul de a-si exprima punctul de vedere',
                'implementation': 'Mecanism de apel/revizuire necesar'
            },
            {
                'requirement': 'contest_decision',
                'description': 'Dreptul de a contesta decizia',
                'implementation': 'Proces de revizuire a deciziei necesar'
            },
            {
                'requirement': 'meaningful_information',
                'description': 'Informatii despre logica implicata',
                'implementation': 'Sistem de explicare necesar'
            }
        ]
 
        # Additional safeguards for special category data (Article 22(4))
        if adm_entry['special_category_data']:
            safeguards.append({
                'requirement': 'explicit_consent_or_substantial_public_interest',
                'description': 'Baza juridica Articolul 9(2)(a) sau (g) necesara',
                'implementation': 'Mecanism de consimtamant sau documentatie baza juridica'
            })
            safeguards.append({
                'requirement': 'suitable_measures',
                'description': 'Masuri adecvate pentru protejarea drepturilor',
                'implementation': 'Controale de securitate si acces sporite'
            })
 
        return safeguards
 
    def record_automated_decision(self, system_id: str,
                                  decision: dict) -> str:
        """Inregistreaza o decizie automatizata pentru conformitate."""
 
        decision_id = str(uuid.uuid4())
 
        decision_record = {
            'decision_id': decision_id,
            'system_id': system_id,
            'data_subject_id': decision['data_subject_id'],
            'timestamp': datetime.utcnow().isoformat(),
            'input_data': decision['input_data'],
            'output': decision['output'],
            'confidence': decision.get('confidence'),
            'explanation': decision.get('explanation'),
            'human_reviewed': False,
            'contested': False
        }
 
        # Store decision record
        self._store_decision(decision_record)
 
        return decision_id
 
    def request_human_review(self, decision_id: str,
                            requester_id: str,
                            reason: str) -> dict:
        """Gestioneaza cererea de interventie umana in decizia automatizata."""
 
        decision = self._get_decision(decision_id)
 
        # Create review request
        review_request = {
            'request_id': str(uuid.uuid4()),
            'decision_id': decision_id,
            'requester_id': requester_id,
            'reason': reason,
            'requested_at': datetime.utcnow().isoformat(),
            'status': 'pending',
            'assigned_reviewer': self._assign_reviewer(),
            'deadline': (datetime.utcnow() + timedelta(days=7)).isoformat()
        }
 
        # Notify reviewer
        self._notify_reviewer(review_request)
 
        return review_request
 
    def _assign_reviewer(self) -> str:
        """Atribuie un revizor uman pentru revizuirea deciziei."""
        # Round-robin or load-balanced assignment
        return self.human_reviewers[0] if self.human_reviewers else 'unassigned'

class PrivacyByDesignAI:
    """Implementeaza principiile privacy by design in sistemele AI."""
 
    techniques = {
        'differential_privacy': {
            'description': 'Adauga zgomot calibrat pentru a proteja inregistrarile individuale',
            'use_cases': ['Antrenarea modelului', 'Raspunsuri la interogari', 'Publicarea datelor'],
            'trade_offs': 'Confidentialitate vs acuratete/utilitate'
        },
        'federated_learning': {
            'description': 'Antreneaza modele pe date descentralizate',
            'use_cases': ['AI mobil', 'Sanatate', 'Colaborare multi-organizatie'],
            'trade_offs': 'Overhead de comunicare, convergenta modelului'
        },
        'secure_multi_party_computation': {
            'description': 'Calculeaza pe date criptate de la mai multe parti',
            'use_cases': ['Analiza colaborativa', 'Inferenta privata'],
            'trade_offs': 'Overhead computational'
        },
        'homomorphic_encryption': {
            'description': 'Efectueaza calcule pe date criptate',
            'use_cases': ['ML in cloud', 'Inferenta privata'],
            'trade_offs': 'Cost computational semnificativ'
        },
        'data_anonymization': {
            'description': 'Elimina sau transforma informatiile de identificare',
            'use_cases': ['Pregatirea datelor de antrenament', 'Partajarea datelor'],
            'trade_offs': 'Risc de re-identificare, pierderea utilitatii datelor'
        },
        'synthetic_data': {
            'description': 'Genereaza date artificiale pastrind proprietatile statistice',
            'use_cases': ['Testare', 'Dezvoltare', 'Antrenament'],
            'trade_offs': 'S-ar putea sa nu capteze toate pattern-urile din lumea reala'
        }
    }
 
    def implement_data_minimization(self, dataset: dict) -> dict:
        """Aplica principiile de minimizare a datelor."""
 
        minimization_steps = []
 
        # 1. Feature selection - keep only necessary features
        necessary_features = self._identify_necessary_features(dataset)
        minimization_steps.append({
            'step': 'feature_selection',
            'original_features': len(dataset['features']),
            'retained_features': len(necessary_features),
            'removed_features': [
                f for f in dataset['features']
                if f not in necessary_features
            ]
        })
 
        # 2. Generalization - reduce precision where possible
        generalized = self._apply_generalization(dataset, necessary_features)
        minimization_steps.append({
            'step': 'generalization',
            'fields_generalized': generalized['fields']
        })
 
        # 3. Pseudonymization - replace identifiers
        pseudonymized = self._apply_pseudonymization(dataset)
        minimization_steps.append({
            'step': 'pseudonymization',
            'identifiers_replaced': pseudonymized['replaced_fields']
        })
 
        return {
            'original_dataset': dataset['id'],
            'minimized_dataset': pseudonymized['dataset'],
            'steps_applied': minimization_steps,
            'data_utility_assessment': self._assess_utility(
                dataset, pseudonymized['dataset']
            )
        }
 
    def implement_purpose_limitation(self, model: dict,
                                    purposes: List[str]) -> dict:
        """Implementeaza controale de limitare a scopului."""
 
        controls = {
            'model_id': model['id'],
            'approved_purposes': purposes,
            'implementation': []
        }
 
        # 1. Purpose-bound model wrapper
        controls['implementation'].append({
            'control': 'purpose_validation',
            'description': 'Valideaza scopul inainte de inferenta',
            'code_example': '''
                def inference_with_purpose_check(input, stated_purpose):
                    if stated_purpose not in approved_purposes:
                        raise PurposeLimitationError()
                    return model.predict(input)
            '''
        })
 
        # 2. Audit logging
        controls['implementation'].append({
            'control': 'purpose_logging',
            'description': 'Inregistreaza scopul declarat la fiecare utilizare',
            'fields_logged': ['timestamp', 'user', 'purpose', 'input_hash']
        })
 
        # 3. Purpose-specific output filtering
        controls['implementation'].append({
            'control': 'output_filtering',
            'description': 'Filtreaza output-urile pe baza scopului',
            'example': 'Scopul HR exclude predictiile salariale'
        })
 
        return controls

class AIDPIAFramework:
    """Cadru pentru efectuarea DPIA-urilor pentru sisteme AI."""
 
    def __init__(self):
        self.dpia_template = self._create_template()
 
    def _create_template(self) -> dict:
        """Creeaza sablon DPIA specific pentru AI."""
 
        return {
            'sections': {
                '1_processing_description': {
                    'title': 'Descrierea Procesarii AI',
                    'questions': [
                        'Care este scopul sistemului AI?',
                        'Ce date personale proceseaza AI-ul?',
                        'Care este sursa datelor de antrenament?',
                        'Ce decizii ia sau suporta AI-ul?',
                        'Cine sunt persoanele vizate afectate?',
                        'Care este baza juridica pentru procesare?'
                    ]
                },
                '2_necessity_proportionality': {
                    'title': 'Necesitate si Proportionalitate',
                    'questions': [
                        'Procesarea AI este necesara pentru scop?',
                        'Scopul ar putea fi atins cu mai putine date?',
                        'Exista alternative mai putin intruzive?',
                        'Domeniul procesarii este proportional?'
                    ]
                },
                '3_risk_assessment': {
                    'title': 'Evaluarea Riscurilor Specifice AI',
                    'risk_categories': [
                        {
                            'category': 'Acuratete si Fiabilitate',
                            'risks': [
                                'Erori ale modelului care afecteaza indivizii',
                                'Bias care duce la discriminare',
                                'Drift-ul modelului in timp'
                            ]
                        },
                        {
                            'category': 'Transparenta si Explicabilitate',
                            'risks': [
                                'Incapacitatea de a explica deciziile',
                                'Lipsa informatiilor semnificative pentru subiecti',
                                'Profilare ascunsa'
                            ]
                        },
                        {
                            'category': 'Drepturile Persoanelor Vizate',
                            'risks': [
                                'Dificultatea de a satisface cererile de acces',
                                'Provocari cu stergerea din modele',
                                'Capacitate limitata de a contesta deciziile'
                            ]
                        },
                        {
                            'category': 'Securitate',
                            'risks': [
                                'Extragerea datelor de antrenament',
                                'Furtul modelului',
                                'Manipulare adversariala'
                            ]
                        }
                    ]
                },
                '4_mitigation_measures': {
                    'title': 'Masuri de Atenuare a Riscurilor',
                    'measure_types': [
                        'Masuri tehnice',
                        'Masuri organizationale',
                        'Masuri de transparenta',
                        'Masuri pentru drepturile persoanelor vizate'
                    ]
                },
                '5_consultation': {
                    'title': 'Cerinte de Consultare',
                    'questions': [
                        'Persoanele vizate sau reprezentantii lor au fost consultati?',
                        'Este necesara consultarea autoritatii de supraveghere?',
                        'Ce sfat de specialitate a fost obtinut?'
                    ]
                }
            }
        }
 
    def conduct_dpia(self, ai_system: dict) -> dict:
        """Efectueaza DPIA pentru sistemul AI."""
 
        dpia = {
            'dpia_id': str(uuid.uuid4()),
            'ai_system': ai_system['name'],
            'assessment_date': datetime.utcnow().isoformat(),
            'assessor': ai_system.get('assessor'),
            'sections': {}
        }
 
        # Assess each section
        for section_id, section in self.dpia_template['sections'].items():
            if section_id == '3_risk_assessment':
                dpia['sections'][section_id] = self._assess_risks(ai_system, section)
            else:
                dpia['sections'][section_id] = self._gather_section_info(
                    ai_system, section
                )
 
        # Generate recommendations
        dpia['recommendations'] = self._generate_recommendations(dpia)
 
        # Determine if residual risk is acceptable
        dpia['residual_risk_acceptable'] = self._assess_residual_risk(dpia)
 
        # Determine if supervisory authority consultation needed
        dpia['consultation_required'] = not dpia['residual_risk_acceptable']
 
        return dpia

class GDPRAIComplianceMonitor:
    """Monitorizarea continua a conformitatii pentru sistemele AI."""
 
    def __init__(self, config: dict):
        self.checks = self._define_compliance_checks()
 
    def run_compliance_assessment(self, ai_system: dict) -> dict:
        """Executa evaluarea conformitatii pentru sistemul AI."""
 
        assessment = {
            'system_id': ai_system['id'],
            'assessment_date': datetime.utcnow().isoformat(),
            'checks': [],
            'overall_compliance': True
        }
 
        for check in self.checks:
            result = check['function'](ai_system)
            assessment['checks'].append({
                'check_id': check['id'],
                'name': check['name'],
                'passed': result['passed'],
                'details': result.get('details'),
                'remediation': result.get('remediation') if not result['passed'] else None
            })
 
            if not result['passed']:
                assessment['overall_compliance'] = False
 
        return assessment
 
    def _define_compliance_checks(self) -> List[dict]:
        """Defineste verificarile de conformitate."""
 
        return [
            {
                'id': 'GDPR-AI-001',
                'name': 'Baza juridica documentata',
                'function': self._check_legal_basis
            },
            {
                'id': 'GDPR-AI-002',
                'name': 'Notificarea de confidentialitate actualizata pentru AI',
                'function': self._check_privacy_notice
            },
            {
                'id': 'GDPR-AI-003',
                'name': 'Procese pentru drepturile persoanelor vizate',
                'function': self._check_rights_processes
            },
            {
                'id': 'GDPR-AI-004',
                'name': 'Masuri de protectie Articolul 22',
                'function': self._check_article_22
            },
            {
                'id': 'GDPR-AI-005',
                'name': 'DPIA finalizat',
                'function': self._check_dpia
            },
            {
                'id': 'GDPR-AI-006',
                'name': 'Minimizarea datelor aplicata',
                'function': self._check_minimization
            },
            {
                'id': 'GDPR-AI-007',
                'name': 'Masuri de securitate adecvate',
                'function': self._check_security
            },
            {
                'id': 'GDPR-AI-008',
                'name': 'Perioade de retentie definite',
                'function': self._check_retention
            }
        ]