// Bottom-up estimation from detailed task breakdown

class BottomUpEstimation {
  constructor(project) {
    this.project = project;
    this.tasks = [];
    this.workBreakdownStructure = {};
  }

  createWBS() {
    // Work Breakdown Structure example
    return {
      level1: "Full Project",
      level2: ["Planning", "Design", "Development", "Testing", "Deployment"],
      level3: {
        Development: [
          "Backend API",
          "Frontend UI",
          "Database Schema",
          "Integration",
        ],
        Testing: [
          "Unit Testing",
          "Integration Testing",
          "UAT",
          "Performance Testing",
        ],
      },
    };
  }

  estimateTasks(tasks) {
    let totalEstimate = 0;
    const estimates = [];

    for (let task of tasks) {
      const taskEstimate = this.estimateSingleTask(task);
      estimates.push({
        name: task.name,
        effort: taskEstimate.effort,
        resources: taskEstimate.resources,
        risk: taskEstimate.risk,
        duration: taskEstimate.duration,
      });
      totalEstimate += taskEstimate.effort;
    }

    return {
      totalEffortHours: totalEstimate,
      totalWorkDays: totalEstimate / 8,
      taskDetails: estimates,
      criticalPath: this.identifyCriticalPath(estimates),
    };
  }

  estimateSingleTask(task) {
    // Base effort
    let effort = task.complexity * task.scope;

    // Adjust for team experience
    const experienceFactor = task.teamExperience / 100; // 0.5 to 1.5
    effort = effort * experienceFactor;

    // Adjust for risk
    const riskFactor = 1 + task.riskLevel * 0.1;
    effort = effort * riskFactor;

    return {
      effort: Math.ceil(effort),
      resources: Math.ceil(effort / 8), // days
      risk: task.riskLevel,
      duration: Math.ceil(effort / (8 * task.teamSize)),
    };
  }

  identifyCriticalPath(estimates) {
    // Return tasks with longest duration
    return estimates.sort((a, b) => b.duration - a.duration).slice(0, 5);
  }
}

// Resource allocation and estimation

class ResourceEstimation {
  calculateResourceNeeds(projectDuration, tasks) {
    const resourceMap = {
      "Senior Developer": 0,
      "Mid-Level Developer": 0,
      "Junior Developer": 0,
      "QA Engineer": 0,
      "DevOps Engineer": 0,
      "Project Manager": 0,
    };

    let totalEffort = 0;

    for (let task of tasks) {
      resourceMap[task.requiredRole] += task.effortHours;
      totalEffort += task.effortHours;
    }

    // Calculate FTE (Full Time Equivalent) needed
    const fteMap = {};
    for (let role in resourceMap) {
      fteMap[role] = (resourceMap[role] / (projectDuration * 8 * 5)).toFixed(2);
    }

    return {
      effortByRole: resourceMap,
      fte: fteMap,
      totalEffortHours: totalEffort,
      totalWorkDays: totalEffort / 8,
      costEstimate: this.calculateCost(fteMap),
    };
  }

  calculateCost(fteMap) {
    const dailyRates = {
      "Senior Developer": 1200,
      "Mid-Level Developer": 900,
      "Junior Developer": 600,
      "QA Engineer": 700,
      "DevOps Engineer": 950,
      "Project Manager": 800,
    };

    let totalCost = 0;
    const costByRole = {};

    for (let role in fteMap) {
      const fteDays = fteMap[role] * 250; // 250 working days/year
      costByRole[role] = fteDays * dailyRates[role];
      totalCost += costByRole[role];
    }

    return {
      byRole: costByRole,
      total: totalCost,
      currency: "USD",
    };
  }
}