interface ParticipationMetrics {
  totalParticipants: number;
  participantBreakdown: {
    developers: number;
    designers: number;
    businessPeople: number;
    others: number;
  };
  retentionRate: number; // % que permaneceu até o final
  teamFormationRate: number; // % em times
  averageTeamSize: number;
}

const calculateEngagementScore = (metrics: ParticipationMetrics): number => {
  const {
    totalParticipants,
    retentionRate,
    teamFormationRate,
  } = metrics;
  
  return (
    (retentionRate * 0.4) +
    (teamFormationRate * 0.4) +
    (Math.min(totalParticipants / 100, 1) * 0.2)
  ) * 100;
};

interface DiversityMetrics {
  genderDistribution: {
    female: number;
    male: number;
    nonBinary: number;
    other: number;
  };
  ageGroups: {
    under18: number;
    '18-25': number;
    '26-35': number;
    '36-50': number;
    over50: number;
  };
  experienceLevels: {
    student: number;
    junior: number;
    senior: number;
    expert: number;
  };
  geographicDistribution: Map<string, number>; // bairros/regiões
}

const calculateDiversityIndex = (metrics: DiversityMetrics): number => {
  // Índice de Simpson para diversidade
  const calculateSimpsonIndex = (distribution: Record<string, number>) => {
    const total = Object.values(distribution).reduce((a, b) => a + b, 0);
    return 1 - Object.values(distribution)
      .reduce((acc, val) => acc + Math.pow(val / total, 2), 0);
  };
  
  const genderDiversity = calculateSimpsonIndex(metrics.genderDistribution);
  const ageDiversity = calculateSimpsonIndex(metrics.ageGroups);
  const experienceDiversity = calculateSimpsonIndex(metrics.experienceLevels);
  
  return (genderDiversity + ageDiversity + experienceDiversity) / 3;
};

interface ProjectMetrics {
  totalProjects: number;
  projectScores: {
    innovation: number; // 0-10
    feasibility: number; // 0-10
    presentation: number; // 0-10
    marketPotential: number; // 0-10
    technicalExecution: number; // 0-10
  }[];
  continuationRate: number; // % projetos que continuaram após o evento
  mentorFeedback: {
    projectId: string;
    scores: number[];
    comments: string[];
  }[];
}

const evaluateProjectQuality = (metrics: ProjectMetrics): ProjectEvaluation => {
  const averageScores = metrics.projectScores.reduce(
    (acc, scores) => ({
      innovation: acc.innovation + scores.innovation,
      feasibility: acc.feasibility + scores.feasibility,
      presentation: acc.presentation + scores.presentation,
      marketPotential: acc.marketPotential + scores.marketPotential,
      technicalExecution: acc.technicalExecution + scores.technicalExecution,
    }),
    {
      innovation: 0,
      feasibility: 0,
      presentation: 0,
      marketPotential: 0,
      technicalExecution: 0,
    }
  );
  
  const totalProjects = metrics.projectScores.length;
  
  return {
    averageScores: {
      innovation: averageScores.innovation / totalProjects,
      feasibility: averageScores.feasibility / totalProjects,
      presentation: averageScores.presentation / totalProjects,
      marketPotential: averageScores.marketPotential / totalProjects,
      technicalExecution: averageScores.technicalExecution / totalProjects,
    },
    continuationRate: metrics.continuationRate,
    overallQualityScore: Object.values(averageScores)
      .reduce((a, b) => a + b, 0) / (5 * totalProjects),
  };
};

interface CommunityImpactMetrics {
  localPartnerships: number;
  mentorEngagement: {
    totalMentors: number;
    hoursContributed: number;
    mentorSatisfaction: number; // 0-10
  };
  mediaCoverage: {
    articles: number;
    socialMediaMentions: number;
    reach: number;
  };
  communityFeedback: {
    nps: number; // Net Promoter Score
    testimonials: string[];
    improvementSuggestions: string[];
  };
}

const calculateCommunityImpact = (
  metrics: CommunityImpactMetrics
): ImpactScore => {
  const mentorScore = (
    (metrics.mentorEngagement.totalMentors / 20) * 0.4 +
    (metrics.mentorEngagement.mentorSatisfaction / 10) * 0.6
  ) * 100;
  
  const mediaScore = Math.min(
    (
      (metrics.mediaContent.articles * 10) +
      (metrics.mediaContent.socialMediaMentions * 0.1) +
      (metrics.mediaContent.reach / 1000)
    ) / 100,
    100
  );
  
  const npsScore = ((metrics.communityFeedback.nps + 100) / 2);
  
  return {
    mentorEngagementScore: mentorScore,
    mediaCoverageScore: mediaScore,
    communityFeedbackScore: npsScore,
    overallImpactScore: (
      mentorScore * 0.3 +
      mediaScore * 0.3 +
      npsScore * 0.4
    ),
  };
};

interface EventDashboard {
  realTimeMetrics: {
    currentAttendance: number;
    activeTeams: number;
    mentoringSessions: number;
    upcomingPresentations: number;
  };
  historicalData: {
    previousEvents: EventMetrics[];
    trends: TrendAnalysis;
    benchmarks: Benchmarks;
  };
  alerts: {
    type: 'warning' | 'success' | 'info';
    message: string;
    timestamp: Date;
  }[];
}

class EventMonitor {
  private dashboard: EventDashboard;
  
  constructor() {
    this.dashboard = {
      realTimeMetrics: {
        currentAttendance: 0,
        activeTeams: 0,
        mentoringSessions: 0,
        upcomingPresentations: 0,
      },
      historicalData: {
        previousEvents: [],
        trends: {
          participationTrend: [],
          satisfactionTrend: [],
          projectSuccessTrend: [],
        },
        benchmarks: {
          regional: {},
          national: {},
          global: {},
        },
      },
      alerts: [],
    };
  }
  
  updateMetrics(metrics: Partial<RealTimeMetrics>) {
    this.dashboard.realTimeMetrics = {
      ...this.dashboard.realTimeMetrics,
      ...metrics,
    };
    
    this.checkThresholds();
  }
  
  private checkThresholds() {
    const {
      currentAttendance,
      activeTeams,
      mentoringSessions,
    } = this.dashboard.realTimeMetrics;
    
    if (currentAttendance < activeTeams * 3) {
      this.addAlert({
        type: 'warning',
        message: 'Possível subdivisão excessiva de times',
        timestamp: new Date(),
      });
    }
    
    if (mentoringSessions > activeTeams * 2) {
      this.addAlert({
        type: 'info',
        message: 'Alta demanda por mentoria - considere ajustes',
        timestamp: new Date(),
      });
    }
  }
}

interface FeedbackAnalysis {
  quantitative: {
    overallSatisfaction: number; // 0-10
    eventOrganization: number; // 0-10
    mentorQuality: number; // 0-10
    learningExperience: number; // 0-10
    networkingOpportunities: number; // 0-10
  };
  qualitative: {
    strengths: string[];
    weaknesses: string[];
    suggestions: string[];
  };
  sentimentAnalysis: {
    positive: number;
    neutral: number;
    negative: number;
  };
}

class FeedbackAnalyzer {
  analyzeFeedback(
    responses: SurveyResponse[]
  ): FeedbackAnalysis {
    const quantitative = this.calculateAverages(responses);
    const qualitative = this.categorizeComments(responses);
    const sentiment = this.analyzeSentiment(responses);
    
    return {
      quantitative,
      qualitative,
      sentimentAnalysis: sentiment,
    };
  }
  
  private calculateAverages(
    responses: SurveyResponse[]
  ): QuantitativeMetrics {
    return responses.reduce(
      (acc, response) => ({
        overallSatisfaction:
          acc.overallSatisfaction + response.satisfaction,
        eventOrganization:
          acc.eventOrganization + response.organization,
        mentorQuality:
          acc.mentorQuality + response.mentorship,
        learningExperience:
          acc.learningExperience + response.learning,
        networkingOpportunities:
          acc.networkingOpportunities + response.networking,
      }),
      {
        overallSatisfaction: 0,
        eventOrganization: 0,
        mentorQuality: 0,
        learningExperience: 0,
        networkingOpportunities: 0,
      }
    );
  }
}

interface RegionalComparison {
  region: string;
  metrics: {
    averageParticipants: number;
    averageTeams: number;
    successRate: number;
    communityEngagement: number;
  };
  ranking: {
    national: number;
    global: number;
  };
}

const analyzeRegionalPerformance = (
  eventMetrics: EventMetrics,
  regionalData: RegionalComparison[]
): PerformanceAnalysis => {
  const regionalAverage = regionalData.reduce(
    (acc, region) => ({
      participants:
        acc.participants + region.metrics.averageParticipants,
      teams:
        acc.teams + region.metrics.averageTeams,
      success:
        acc.success + region.metrics.successRate,
      engagement:
        acc.engagement + region.metrics.communityEngagement,
    }),
    {
      participants: 0,
      teams: 0,
      success: 0,
      engagement: 0,
    }
  );
  
  const totalRegions = regionalData.length;
  
  return {
    participantsPerformance:
      eventMetrics.totalParticipants /
      (regionalAverage.participants / totalRegions),
    teamsPerformance:
      eventMetrics.totalTeams /
      (regionalAverage.teams / totalRegions),
    successPerformance:
      eventMetrics.successRate /
      (regionalAverage.success / totalRegions),
    engagementPerformance:
      eventMetrics.communityEngagement /
      (regionalAverage.engagement / totalRegions),
  };
};