import { AIEmployeeRole } from "./aiEmployeeSystem.ts";

/**
 * AI performance metrics
 */
export interface AIPerformanceMetrics {
  employeeRole: AIEmployeeRole;
  tasksAssigned: number;
  tasksCompleted: number;
  tasksApproved: number;
  tasksDenied: number;
  averageCompletionTime: number; // minutes
  approvalRate: number; // percentage
  reportsSubmitted: number;
  reportsApproved: number;
  averageReportQuality: number; // 1-10
  lastReportTime: string;
  performanceScore: number; // 1-100
  updatedAt: string;
}

/**
 * Performance metrics storage (in-memory, can be replaced with database)
 */
const metricsStore: Map<AIEmployeeRole, AIPerformanceMetrics> = new Map();

/**
 * Initialize default metrics for all AI employees
 */
export function initializeMetrics(): void {
  const roles = Object.values(AIEmployeeRole);
  for (const role of roles) {
    metricsStore.set(role, {
      employeeRole: role,
      tasksAssigned: 0,
      tasksCompleted: 0,
      tasksApproved: 0,
      tasksDenied: 0,
      averageCompletionTime: 0,
      approvalRate: 0,
      reportsSubmitted: 0,
      reportsApproved: 0,
      averageReportQuality: 0,
      lastReportTime: new Date().toISOString(),
      performanceScore: 75, // Starting score
      updatedAt: new Date().toISOString(),
    });
  }
  console.log("[AIPerformanceMetrics] Metrics initialized for all AI employees");
}

/**
 * Record task assignment
 */
export function recordTaskAssignment(employeeRole: AIEmployeeRole): void {
  const metrics = metricsStore.get(employeeRole);
  if (metrics) {
    metrics.tasksAssigned++;
    metrics.updatedAt = new Date().toISOString();
    metricsStore.set(employeeRole, metrics);
  }
}

/**
 * Record task completion
 */
export function recordTaskCompletion(employeeRole: AIEmployeeRole, completionTimeMinutes: number): void {
  const metrics = metricsStore.get(employeeRole);
  if (metrics) {
    metrics.tasksCompleted++;
    // Update average completion time
    metrics.averageCompletionTime =
      (metrics.averageCompletionTime * (metrics.tasksCompleted - 1) + completionTimeMinutes) / metrics.tasksCompleted;
    metrics.updatedAt = new Date().toISOString();
    metricsStore.set(employeeRole, metrics);
  }
}

/**
 * Record task approval
 */
export function recordTaskApproval(employeeRole: AIEmployeeRole): void {
  const metrics = metricsStore.get(employeeRole);
  if (metrics) {
    metrics.tasksApproved++;
    metrics.approvalRate = (metrics.tasksApproved / (metrics.tasksApproved + metrics.tasksDenied)) * 100;
    metrics.updatedAt = new Date().toISOString();
    metricsStore.set(employeeRole, metrics);
  }
}

/**
 * Record task denial
 */
export function recordTaskDenial(employeeRole: AIEmployeeRole): void {
  const metrics = metricsStore.get(employeeRole);
  if (metrics) {
    metrics.tasksDenied++;
    metrics.approvalRate = (metrics.tasksApproved / (metrics.tasksApproved + metrics.tasksDenied)) * 100;
    metrics.updatedAt = new Date().toISOString();
    metricsStore.set(employeeRole, metrics);
  }
}

/**
 * Record report submission
 */
export function recordReportSubmission(employeeRole: AIEmployeeRole, qualityScore: number): void {
  const metrics = metricsStore.get(employeeRole);
  if (metrics) {
    metrics.reportsSubmitted++;
    // Update average report quality
    metrics.averageReportQuality =
      (metrics.averageReportQuality * (metrics.reportsSubmitted - 1) + qualityScore) / metrics.reportsSubmitted;
    metrics.lastReportTime = new Date().toISOString();
    metrics.updatedAt = new Date().toISOString();
    metricsStore.set(employeeRole, metrics);
  }
}

/**
 * Record report approval
 */
export function recordReportApproval(employeeRole: AIEmployeeRole): void {
  const metrics = metricsStore.get(employeeRole);
  if (metrics) {
    metrics.reportsApproved++;
    metrics.updatedAt = new Date().toISOString();
    metricsStore.set(employeeRole, metrics);
  }
}

/**
 * Calculate performance score (1-100)
 */
function calculatePerformanceScore(metrics: AIPerformanceMetrics): number {
  let score = 50; // Base score

  // Task completion rate (max 25 points)
  if (metrics.tasksAssigned > 0) {
    const completionRate = metrics.tasksCompleted / metrics.tasksAssigned;
    score += completionRate * 25;
  }

  // Approval rate (max 25 points)
  score += metrics.approvalRate * 0.25;

  // Report quality (max 20 points)
  score += (metrics.averageReportQuality / 10) * 20;

  // Consistency bonus (max 10 points)
  if (metrics.reportsSubmitted >= 5) {
    score += 10;
  }

  return Math.min(100, Math.max(0, score));
}

/**
 * Update performance score for an AI employee
 */
export function updatePerformanceScore(employeeRole: AIEmployeeRole): void {
  const metrics = metricsStore.get(employeeRole);
  if (metrics) {
    metrics.performanceScore = calculatePerformanceScore(metrics);
    metrics.updatedAt = new Date().toISOString();
    metricsStore.set(employeeRole, metrics);
  }
}

/**
 * Get metrics for a specific AI employee
 */
export function getMetrics(employeeRole: AIEmployeeRole): AIPerformanceMetrics | undefined {
  return metricsStore.get(employeeRole);
}

/**
 * Get all metrics
 */
export function getAllMetrics(): AIPerformanceMetrics[] {
  return Array.from(metricsStore.values());
}

/**
 * Get top performing AI employees
 */
export function getTopPerformers(limit: number = 5): AIPerformanceMetrics[] {
  return Array.from(metricsStore.values())
    .sort((a, b) => b.performanceScore - a.performanceScore)
    .slice(0, limit);
}

/**
 * Get metrics summary
 */
export function getMetricsSummary(): {
  totalTasksAssigned: number;
  totalTasksCompleted: number;
  totalReportsSubmitted: number;
  averageApprovalRate: number;
  averagePerformanceScore: number;
  topPerformer: AIPerformanceMetrics | undefined;
} {
  const allMetrics = getAllMetrics();

  const totalTasksAssigned = allMetrics.reduce((sum, m) => sum + m.tasksAssigned, 0);
  const totalTasksCompleted = allMetrics.reduce((sum, m) => sum + m.tasksCompleted, 0);
  const totalReportsSubmitted = allMetrics.reduce((sum, m) => sum + m.reportsSubmitted, 0);
  const averageApprovalRate = allMetrics.reduce((sum, m) => sum + m.approvalRate, 0) / allMetrics.length;
  const averagePerformanceScore = allMetrics.reduce((sum, m) => sum + m.performanceScore, 0) / allMetrics.length;
  const topPerformer = getTopPerformers(1)[0];

  return {
    totalTasksAssigned,
    totalTasksCompleted,
    totalReportsSubmitted,
    averageApprovalRate,
    averagePerformanceScore,
    topPerformer,
  };
}

/**
 * Reset metrics (for testing)
 */
export function resetMetrics(): void {
  metricsStore.clear();
  initializeMetrics();
  console.log("[AIPerformanceMetrics] Metrics reset");
}