1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import json

class AwarenessProgramManagement:
    def __init__(self):
        self.programs = {}
        self.audiences = {}
        self.content_modules = {}
        self.training_sessions = {}
        self.assessments = {}
        self.metrics = {}
    
    def create_awareness_program(self, program_id, program_config):
        """Crear programa de concienciación"""
        self.programs[program_id] = {
            'program_id': program_id,
            'name': program_config['name'],
            'description': program_config['description'],
            'objectives': program_config.get('objectives', []),
            'target_audiences': program_config.get('target_audiences', []),
            'duration_months': program_config.get('duration_months', 12),
            'frequency': program_config.get('frequency', 'monthly'),
            'delivery_methods': program_config.get('delivery_methods', ['online']),
            'success_metrics': program_config.get('success_metrics', []),
            'status': 'active',
            'created_date': datetime.now(),
            'last_updated': datetime.now()
        }
    
    def define_audience(self, audience_id, audience_config):
        """Definir audiencia objetivo"""
        self.audiences[audience_id] = {
            'audience_id': audience_id,
            'name': audience_config['name'],
            'description': audience_config['description'],
            'role_level': audience_config.get('role_level', 'general'),
            'department': audience_config.get('department', 'all'),
            'risk_level': audience_config.get('risk_level', 'medium'),
            'specific_needs': audience_config.get('specific_needs', []),
            'learning_preferences': audience_config.get('learning_preferences', []),
            'size': audience_config.get('size', 0),
            'current_knowledge_level': audience_config.get('current_knowledge_level', 'beginner')
        }
    
    def create_content_module(self, module_id, module_config):
        """Crear módulo de contenido"""
        self.content_modules[module_id] = {
            'module_id': module_id,
            'title': module_config['title'],
            'description': module_config['description'],
            'content_type': module_config['content_type'],
            'duration_minutes': module_config.get('duration_minutes', 30),
            'difficulty_level': module_config.get('difficulty_level', 'intermediate'),
            'target_audiences': module_config.get('target_audiences', []),
            'learning_objectives': module_config.get('learning_objectives', []),
            'content_elements': module_config.get('content_elements', []),
            'interactive_elements': module_config.get('interactive_elements', []),
            'assessment_questions': module_config.get('assessment_questions', []),
            'created_date': datetime.now(),
            'version': 1.0
        }
    
    def schedule_training_session(self, session_id, session_config):
        """Programar sesión de entrenamiento"""
        self.training_sessions[session_id] = {
            'session_id': session_id,
            'program_id': session_config['program_id'],
            'module_id': session_config['module_id'],
            'audience_id': session_config['audience_id'],
            'scheduled_date': session_config['scheduled_date'],
            'duration_minutes': session_config.get('duration_minutes', 60),
            'delivery_method': session_config.get('delivery_method', 'online'),
            'instructor': session_config.get('instructor', 'system'),
            'max_participants': session_config.get('max_participants', 50),
            'status': 'scheduled',
            'participants': [],
            'completion_rate': 0.0,
            'feedback_score': 0.0
        }
    
    def register_participant(self, session_id, participant_data):
        """Registrar participante en sesión"""
        if session_id not in self.training_sessions:
            return False
        
        participant = {
            'participant_id': participant_data['participant_id'],
            'name': participant_data['name'],
            'email': participant_data['email'],
            'role': participant_data.get('role', 'employee'),
            'department': participant_data.get('department', 'unknown'),
            'registration_date': datetime.now(),
            'attendance_status': 'registered',
            'completion_status': 'pending',
            'completion_date': None,
            'score': None,
            'feedback': None
        }
        
        self.training_sessions[session_id]['participants'].append(participant)
        return True
    
    def conduct_assessment(self, session_id, assessment_data):
        """Realizar evaluación de conocimiento"""
        if session_id not in self.training_sessions:
            return False
        
        assessment_id = f"ASSESS-{len(self.assessments) + 1}"
        
        assessment = {
            'assessment_id': assessment_id,
            'session_id': session_id,
            'participant_id': assessment_data['participant_id'],
            'questions': assessment_data['questions'],
            'answers': assessment_data['answers'],
            'score': assessment_data['score'],
            'max_score': assessment_data['max_score'],
            'percentage': (assessment_data['score'] / assessment_data['max_score'] * 100) if assessment_data['max_score'] > 0 else 0,
            'completion_time': assessment_data.get('completion_time', 0),
            'timestamp': datetime.now(),
            'passed': assessment_data['score'] >= (assessment_data['max_score'] * 0.7)  # 70% para aprobar
        }
        
        self.assessments[assessment_id] = assessment
        
        # Actualizar estado del participante
        session = self.training_sessions[session_id]
        for participant in session['participants']:
            if participant['participant_id'] == assessment_data['participant_id']:
                participant['completion_status'] = 'completed' if assessment['passed'] else 'failed'
                participant['completion_date'] = datetime.now()
                participant['score'] = assessment['percentage']
                break
        
        # Actualizar tasa de finalización de la sesión
        completed_participants = len([p for p in session['participants'] if p['completion_status'] == 'completed'])
        total_participants = len(session['participants'])
        session['completion_rate'] = (completed_participants / total_participants * 100) if total_participants > 0 else 0
        
        return True
    
    def collect_feedback(self, session_id, feedback_data):
        """Recopilar feedback de participantes"""
        if session_id not in self.training_sessions:
            return False
        
        feedback = {
            'feedback_id': f"FEEDBACK-{len(self.training_sessions[session_id].get('feedback', [])) + 1}",
            'participant_id': feedback_data['participant_id'],
            'rating': feedback_data['rating'],  # 1-5 scale
            'content_quality': feedback_data.get('content_quality', 0),
            'instructor_effectiveness': feedback_data.get('instructor_effectiveness', 0),
            'delivery_method': feedback_data.get('delivery_method', 0),
            'relevance': feedback_data.get('relevance', 0),
            'comments': feedback_data.get('comments', ''),
            'suggestions': feedback_data.get('suggestions', ''),
            'timestamp': datetime.now()
        }
        
        if 'feedback' not in self.training_sessions[session_id]:
            self.training_sessions[session_id]['feedback'] = []
        
        self.training_sessions[session_id]['feedback'].append(feedback)
        
        # Actualizar score de feedback de la sesión
        session = self.training_sessions[session_id]
        feedback_scores = [f['rating'] for f in session.get('feedback', [])]
        if feedback_scores:
            session['feedback_score'] = sum(feedback_scores) / len(feedback_scores)
        
        return True
    
    def calculate_program_metrics(self, program_id):
        """Calcular métricas del programa"""
        if program_id not in self.programs:
            return None
        
        # Obtener sesiones del programa
        program_sessions = [s for s in self.training_sessions.values() if s['program_id'] == program_id]
        
        if not program_sessions:
            return None
        
        # Calcular métricas
        total_sessions = len(program_sessions)
        total_participants = sum(len(s['participants']) for s in program_sessions)
        completed_participants = sum(len([p for p in s['participants'] if p['completion_status'] == 'completed']) for s in program_sessions)
        
        # Calcular tasas
        completion_rate = (completed_participants / total_participants * 100) if total_participants > 0 else 0
        
        # Calcular score promedio
        all_scores = []
        for session in program_sessions:
            session_scores = [p['score'] for p in session['participants'] if p['score'] is not None]
            all_scores.extend(session_scores)
        
        average_score = sum(all_scores) / len(all_scores) if all_scores else 0
        
        # Calcular feedback promedio
        all_feedback_scores = [s['feedback_score'] for s in program_sessions if s['feedback_score'] > 0]
        average_feedback = sum(all_feedback_scores) / len(all_feedback_scores) if all_feedback_scores else 0
        
        # Calcular participación por audiencia
        audience_participation = {}
        for session in program_sessions:
            audience_id = session['audience_id']
            if audience_id not in audience_participation:
                audience_participation[audience_id] = 0
            audience_participation[audience_id] += len(session['participants'])
        
        metrics = {
            'program_id': program_id,
            'total_sessions': total_sessions,
            'total_participants': total_participants,
            'completed_participants': completed_participants,
            'completion_rate': completion_rate,
            'average_score': average_score,
            'average_feedback': average_feedback,
            'audience_participation': audience_participation,
            'effectiveness_score': self.calculate_effectiveness_score(completion_rate, average_score, average_feedback)
        }
        
        return metrics
    
    def calculate_effectiveness_score(self, completion_rate, average_score, average_feedback):
        """Calcular score de efectividad del programa"""
        # Ponderación: 40% completion rate, 40% average score, 20% feedback
        effectiveness = (completion_rate * 0.4) + (average_score * 0.4) + (average_feedback * 20 * 0.2)
        return min(effectiveness, 100)  # Máximo 100
    
    def generate_program_report(self, program_id):
        """Generar reporte del programa"""
        if program_id not in self.programs:
            return None
        
        program = self.programs[program_id]
        metrics = self.calculate_program_metrics(program_id)
        
        if not metrics:
            return None
        
        # Obtener sesiones recientes
        program_sessions = [s for s in self.training_sessions.values() if s['program_id'] == program_id]
        recent_sessions = [s for s in program_sessions if s['scheduled_date'] >= datetime.now() - timedelta(days=30)]
        
        # Análisis de tendencias
        trend_analysis = self.analyze_trends(program_sessions)
        
        # Recomendaciones
        recommendations = self.generate_recommendations(metrics, trend_analysis)
        
        report = {
            'program_id': program_id,
            'program_name': program['name'],
            'report_date': datetime.now(),
            'metrics': metrics,
            'recent_activity': {
                'sessions_last_30_days': len(recent_sessions),
                'participants_last_30_days': sum(len(s['participants']) for s in recent_sessions)
            },
            'trend_analysis': trend_analysis,
            'recommendations': recommendations,
            'status': 'active' if metrics['effectiveness_score'] >= 70 else 'needs_improvement'
        }
        
        return report
    
    def analyze_trends(self, sessions):
        """Analizar tendencias del programa"""
        if len(sessions) < 3:
            return {'trend': 'insufficient_data'}
        
        # Ordenar sesiones por fecha
        sorted_sessions = sorted(sessions, key=lambda x: x['scheduled_date'])
        
        # Analizar tendencia de participación
        participation_trend = []
        for session in sorted_sessions:
            participation_trend.append(len(session['participants']))
        
        # Calcular tendencia usando regresión lineal simple
        x = np.arange(len(participation_trend))
        y = np.array(participation_trend)
        
        if len(x) > 1:
            slope = np.polyfit(x, y, 1)[0]
            if slope > 0.1:
                trend = 'increasing'
            elif slope < -0.1:
                trend = 'decreasing'
            else:
                trend = 'stable'
        else:
            trend = 'stable'
        
        # Analizar tendencia de scores
        score_trend = []
        for session in sorted_sessions:
            session_scores = [p['score'] for p in session['participants'] if p['score'] is not None]
            if session_scores:
                score_trend.append(sum(session_scores) / len(session_scores))
        
        score_trend_direction = 'stable'
        if len(score_trend) > 1:
            score_slope = np.polyfit(np.arange(len(score_trend)), score_trend, 1)[0]
            if score_slope > 0.1:
                score_trend_direction = 'improving'
            elif score_slope < -0.1:
                score_trend_direction = 'declining'
        
        return {
            'participation_trend': trend,
            'score_trend': score_trend_direction,
            'data_points': len(sessions)
        }
    
    def generate_recommendations(self, metrics, trend_analysis):
        """Generar recomendaciones basadas en métricas y tendencias"""
        recommendations = []
        
        # Recomendaciones basadas en métricas
        if metrics['completion_rate'] < 70:
            recommendations.append({
                'type': 'completion_rate',
                'priority': 'high',
                'description': f"Mejorar tasa de finalización - actual: {metrics['completion_rate']:.1f}%"
            })
        
        if metrics['average_score'] < 70:
            recommendations.append({
                'type': 'content_quality',
                'priority': 'high',
                'description': f"Mejorar calidad del contenido - score promedio: {metrics['average_score']:.1f}"
            })
        
        if metrics['average_feedback'] < 3.0:
            recommendations.append({
                'type': 'delivery_method',
                'priority': 'medium',
                'description': f"Mejorar método de entrega - feedback promedio: {metrics['average_feedback']:.1f}/5"
            })
        
        # Recomendaciones basadas en tendencias
        if trend_analysis['participation_trend'] == 'decreasing':
            recommendations.append({
                'type': 'engagement',
                'priority': 'medium',
                'description': "Aumentar engagement - tendencia de participación decreciente"
            })
        
        if trend_analysis['score_trend'] == 'declining':
            recommendations.append({
                'type': 'content_update',
                'priority': 'high',
                'description': "Actualizar contenido - tendencia de scores decreciente"
            })
        
        return recommendations

# Ejemplo de uso
awareness_mgmt = AwarenessProgramManagement()

# Crear programa de concienciación
awareness_mgmt.create_awareness_program('PROG-001', {
    'name': 'Security Awareness Program 2025',
    'description': 'Programa anual de concienciación en seguridad',
    'objectives': [
        'Reducir incidentes de phishing en 50%',
        'Mejorar conocimiento de seguridad en 30%',
        'Aumentar reporte de incidentes en 40%'
    ],
    'target_audiences': ['all_employees', 'managers', 'it_staff'],
    'duration_months': 12,
    'frequency': 'monthly',
    'delivery_methods': ['online', 'in_person', 'simulation']
})

# Definir audiencia
awareness_mgmt.define_audience('AUD-001', {
    'name': 'All Employees',
    'description': 'Todos los empleados de la organización',
    'role_level': 'general',
    'department': 'all',
    'risk_level': 'medium',
    'size': 500,
    'current_knowledge_level': 'beginner'
})

# Crear módulo de contenido
awareness_mgmt.create_content_module('MOD-001', {
    'title': 'Phishing Awareness',
    'description': 'Identificación y prevención de ataques de phishing',
    'content_type': 'interactive_module',
    'duration_minutes': 45,
    'difficulty_level': 'beginner',
    'target_audiences': ['AUD-001'],
    'learning_objectives': [
        'Identificar correos de phishing',
        'Reportar correos sospechosos',
        'Aplicar mejores prácticas de seguridad'
    ],
    'content_elements': ['videos', 'quizzes', 'simulations'],
    'interactive_elements': ['phishing_simulation', 'knowledge_check']
})

# Programar sesión de entrenamiento
awareness_mgmt.schedule_training_session('SESS-001', {
    'program_id': 'PROG-001',
    'module_id': 'MOD-001',
    'audience_id': 'AUD-001',
    'scheduled_date': datetime.now() + timedelta(days=7),
    'delivery_method': 'online',
    'max_participants': 50
})

# Registrar participantes
awareness_mgmt.register_participant('SESS-001', {
    'participant_id': 'PART-001',
    'name': 'Juan Pérez',
    'email': 'juan.perez@company.com',
    'role': 'employee',
    'department': 'hr'
})

# Realizar evaluación
awareness_mgmt.conduct_assessment('SESS-001', {
    'participant_id': 'PART-001',
    'questions': 10,
    'answers': 8,
    'score': 8,
    'max_score': 10,
    'completion_time': 25
})

# Generar reporte
report = awareness_mgmt.generate_program_report('PROG-001')
print(f"Reporte del programa: {report['program_name']}")
print(f"Score de efectividad: {report['metrics']['effectiveness_score']:.1f}")

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359

class PhishingSimulation:
    def __init__(self):
        self.simulations = {}
        self.campaigns = {}
        self.results = {}
        self.templates = {}
    
    def create_phishing_template(self, template_id, template_config):
        """Crear plantilla de phishing"""
        self.templates[template_id] = {
            'template_id': template_id,
            'name': template_config['name'],
            'subject': template_config['subject'],
            'sender': template_config['sender'],
            'content': template_config['content'],
            'difficulty_level': template_config.get('difficulty_level', 'medium'),
            'phishing_indicators': template_config.get('phishing_indicators', []),
            'target_audience': template_config.get('target_audience', 'all'),
            'created_date': datetime.now()
        }
    
    def create_simulation_campaign(self, campaign_id, campaign_config):
        """Crear campaña de simulación"""
        self.campaigns[campaign_id] = {
            'campaign_id': campaign_id,
            'name': campaign_config['name'],
            'description': campaign_config['description'],
            'template_id': campaign_config['template_id'],
            'target_audience': campaign_config['target_audience'],
            'start_date': campaign_config['start_date'],
            'end_date': campaign_config['end_date'],
            'status': 'scheduled',
            'total_recipients': 0,
            'emails_sent': 0,
            'emails_opened': 0,
            'links_clicked': 0,
            'data_entered': 0,
            'reported_phishing': 0,
            'created_date': datetime.now()
        }
    
    def send_simulation_email(self, campaign_id, recipient_data):
        """Enviar email de simulación"""
        if campaign_id not in self.campaigns:
            return False
        
        campaign = self.campaigns[campaign_id]
        template = self.templates[campaign['template_id']]
        
        simulation_id = f"SIM-{len(self.simulations) + 1}"
        
        simulation = {
            'simulation_id': simulation_id,
            'campaign_id': campaign_id,
            'recipient_id': recipient_data['recipient_id'],
            'recipient_email': recipient_data['email'],
            'recipient_name': recipient_data['name'],
            'template_id': campaign['template_id'],
            'sent_date': datetime.now(),
            'opened': False,
            'opened_date': None,
            'link_clicked': False,
            'link_clicked_date': None,
            'data_entered': False,
            'data_entered_date': None,
            'reported_phishing': False,
            'reported_date': None,
            'response_time_minutes': None
        }
        
        self.simulations[simulation_id] = simulation
        
        # Actualizar estadísticas de la campaña
        campaign['emails_sent'] += 1
        
        return True
    
    def record_email_opened(self, simulation_id):
        """Registrar apertura de email"""
        if simulation_id not in self.simulations:
            return False
        
        simulation = self.simulations[simulation_id]
        simulation['opened'] = True
        simulation['opened_date'] = datetime.now()
        
        # Calcular tiempo de respuesta
        if simulation['sent_date']:
            response_time = simulation['opened_date'] - simulation['sent_date']
            simulation['response_time_minutes'] = response_time.total_seconds() / 60
        
        # Actualizar estadísticas de la campaña
        campaign_id = simulation['campaign_id']
        if campaign_id in self.campaigns:
            self.campaigns[campaign_id]['emails_opened'] += 1
        
        return True
    
    def record_link_clicked(self, simulation_id):
        """Registrar clic en enlace"""
        if simulation_id not in self.simulations:
            return False
        
        simulation = self.simulations[simulation_id]
        simulation['link_clicked'] = True
        simulation['link_clicked_date'] = datetime.now()
        
        # Actualizar estadísticas de la campaña
        campaign_id = simulation['campaign_id']
        if campaign_id in self.campaigns:
            self.campaigns[campaign_id]['links_clicked'] += 1
        
        return True
    
    def record_data_entered(self, simulation_id):
        """Registrar entrada de datos"""
        if simulation_id not in self.simulations:
            return False
        
        simulation = self.simulations[simulation_id]
        simulation['data_entered'] = True
        simulation['data_entered_date'] = datetime.now()
        
        # Actualizar estadísticas de la campaña
        campaign_id = simulation['campaign_id']
        if campaign_id in self.campaigns:
            self.campaigns[campaign_id]['data_entered'] += 1
        
        return True
    
    def record_phishing_report(self, simulation_id):
        """Registrar reporte de phishing"""
        if simulation_id not in self.simulations:
            return False
        
        simulation = self.simulations[simulation_id]
        simulation['reported_phishing'] = True
        simulation['reported_date'] = datetime.now()
        
        # Actualizar estadísticas de la campaña
        campaign_id = simulation['campaign_id']
        if campaign_id in self.campaigns:
            self.campaigns[campaign_id]['reported_phishing'] += 1
        
        return True
    
    def calculate_campaign_metrics(self, campaign_id):
        """Calcular métricas de la campaña"""
        if campaign_id not in self.campaigns:
            return None
        
        campaign = self.campaigns[campaign_id]
        
        # Obtener simulaciones de la campaña
        campaign_simulations = [s for s in self.simulations.values() if s['campaign_id'] == campaign_id]
        
        if not campaign_simulations:
            return None
        
        # Calcular métricas
        total_simulations = len(campaign_simulations)
        opened_simulations = len([s for s in campaign_simulations if s['opened']])
        clicked_simulations = len([s for s in campaign_simulations if s['link_clicked']])
        data_entered_simulations = len([s for s in campaign_simulations if s['data_entered']])
        reported_simulations = len([s for s in campaign_simulations if s['reported_phishing']])
        
        # Calcular tasas
        open_rate = (opened_simulations / total_simulations * 100) if total_simulations > 0 else 0
        click_rate = (clicked_simulations / total_simulations * 100) if total_simulations > 0 else 0
        data_entry_rate = (data_entered_simulations / total_simulations * 100) if total_simulations > 0 else 0
        report_rate = (reported_simulations / total_simulations * 100) if total_simulations > 0 else 0
        
        # Calcular tiempo promedio de respuesta
        response_times = [s['response_time_minutes'] for s in campaign_simulations if s['response_time_minutes'] is not None]
        avg_response_time = sum(response_times) / len(response_times) if response_times else 0
        
        # Calcular score de vulnerabilidad
        vulnerability_score = (click_rate + data_entry_rate - report_rate) / 2
        
        metrics = {
            'campaign_id': campaign_id,
            'total_simulations': total_simulations,
            'open_rate': open_rate,
            'click_rate': click_rate,
            'data_entry_rate': data_entry_rate,
            'report_rate': report_rate,
            'avg_response_time': avg_response_time,
            'vulnerability_score': vulnerability_score,
            'risk_level': self.determine_risk_level(vulnerability_score)
        }
        
        return metrics
    
    def determine_risk_level(self, vulnerability_score):
        """Determinar nivel de riesgo basado en score de vulnerabilidad"""
        if vulnerability_score >= 70:
            return 'critical'
        elif vulnerability_score >= 50:
            return 'high'
        elif vulnerability_score >= 30:
            return 'medium'
        else:
            return 'low'
    
    def generate_campaign_report(self, campaign_id):
        """Generar reporte de campaña"""
        if campaign_id not in self.campaigns:
            return None
        
        campaign = self.campaigns[campaign_id]
        metrics = self.calculate_campaign_metrics(campaign_id)
        
        if not metrics:
            return None
        
        # Análisis de comportamiento
        behavior_analysis = self.analyze_behavior_patterns(campaign_id)
        
        # Recomendaciones
        recommendations = self.generate_phishing_recommendations(metrics, behavior_analysis)
        
        report = {
            'campaign_id': campaign_id,
            'campaign_name': campaign['name'],
            'report_date': datetime.now(),
            'metrics': metrics,
            'behavior_analysis': behavior_analysis,
            'recommendations': recommendations,
            'status': campaign['status']
        }
        
        return report
    
    def analyze_behavior_patterns(self, campaign_id):
        """Analizar patrones de comportamiento"""
        campaign_simulations = [s for s in self.simulations.values() if s['campaign_id'] == campaign_id]
        
        if not campaign_simulations:
            return {'analysis': 'no_data'}
        
        # Análisis por departamento
        dept_analysis = {}
        for sim in campaign_simulations:
            dept = sim.get('department', 'unknown')
            if dept not in dept_analysis:
                dept_analysis[dept] = {
                    'total': 0,
                    'clicked': 0,
                    'reported': 0
                }
            
            dept_analysis[dept]['total'] += 1
            if sim['link_clicked']:
                dept_analysis[dept]['clicked'] += 1
            if sim['reported_phishing']:
                dept_analysis[dept]['reported'] += 1
        
        # Calcular tasas por departamento
        for dept, data in dept_analysis.items():
            data['click_rate'] = (data['clicked'] / data['total'] * 100) if data['total'] > 0 else 0
            data['report_rate'] = (data['reported'] / data['total'] * 100) if data['total'] > 0 else 0
        
        # Análisis temporal
        hourly_analysis = {}
        for sim in campaign_simulations:
            if sim['opened_date']:
                hour = sim['opened_date'].hour
                if hour not in hourly_analysis:
                    hourly_analysis[hour] = {'opened': 0, 'clicked': 0}
                
                hourly_analysis[hour]['opened'] += 1
                if sim['link_clicked']:
                    hourly_analysis[hour]['clicked'] += 1
        
        return {
            'department_analysis': dept_analysis,
            'hourly_analysis': hourly_analysis,
            'total_simulations': len(campaign_simulations)
        }
    
    def generate_phishing_recommendations(self, metrics, behavior_analysis):
        """Generar recomendaciones basadas en métricas de phishing"""
        recommendations = []
        
        # Recomendaciones basadas en métricas
        if metrics['click_rate'] > 30:
            recommendations.append({
                'type': 'click_rate',
                'priority': 'high',
                'description': f"Alta tasa de clics ({metrics['click_rate']:.1f}%) - aumentar entrenamiento en identificación de phishing"
            })
        
        if metrics['data_entry_rate'] > 20:
            recommendations.append({
                'type': 'data_entry',
                'priority': 'critical',
                'description': f"Alta tasa de entrada de datos ({metrics['data_entry_rate']:.1f}%) - riesgo crítico de compromiso"
            })
        
        if metrics['report_rate'] < 10:
            recommendations.append({
                'type': 'reporting',
                'priority': 'high',
                'description': f"Baja tasa de reporte ({metrics['report_rate']:.1f}%) - mejorar canales de reporte"
            })
        
        # Recomendaciones basadas en análisis de comportamiento
        if 'department_analysis' in behavior_analysis:
            for dept, data in behavior_analysis['department_analysis'].items():
                if data['click_rate'] > 40:
                    recommendations.append({
                        'type': 'department_training',
                        'priority': 'medium',
                        'description': f"Entrenamiento específico para {dept} - alta tasa de clics ({data['click_rate']:.1f}%)"
                    })
        
        return recommendations

# Ejemplo de uso
phishing_sim = PhishingSimulation()

# Crear plantilla de phishing
phishing_sim.create_phishing_template('TEMP-001', {
    'name': 'Banking Phishing Template',
    'subject': 'Urgent: Verify Your Account',
    'sender': 'security@bank.com',
    'content': 'Please click here to verify your account...',
    'difficulty_level': 'medium',
    'phishing_indicators': ['urgent_language', 'suspicious_link', 'generic_greeting'],
    'target_audience': 'all'
})

# Crear campaña de simulación
phishing_sim.create_simulation_campaign('CAMP-001', {
    'name': 'Q1 Phishing Simulation',
    'description': 'Simulación de phishing para Q1 2025',
    'template_id': 'TEMP-001',
    'target_audience': 'all_employees',
    'start_date': datetime.now(),
    'end_date': datetime.now() + timedelta(days=7)
})

# Enviar email de simulación
phishing_sim.send_simulation_email('CAMP-001', {
    'recipient_id': 'EMP-001',
    'email': 'employee@company.com',
    'name': 'John Doe'
})

# Registrar eventos
phishing_sim.record_email_opened('SIM-1')
phishing_sim.record_link_clicked('SIM-1')
phishing_sim.record_phishing_report('SIM-1')

# Generar reporte
report = phishing_sim.generate_campaign_report('CAMP-001')
print(f"Reporte de campaña: {report['campaign_name']}")
print(f"Tasa de clics: {report['metrics']['click_rate']:.1f}%")
print(f"Nivel de riesgo: {report['metrics']['risk_level']}")