Revenue Recovery Score™ Methodology

function collectMetrics(companyId: string): RawMetrics {
  return {
    totalCalls:        fetchPhoneSystemLogs(companyId, period).inbound,
    missedCalls:       fetchPhoneSystemLogs(companyId, period).missed,
    afterHoursCalls:   fetchPhoneSystemLogs(companyId, period).afterHours,
    afterHoursAnswered:fetchPhoneSystemLogs(companyId, period).afterHoursAnswered,
    webInquiries:      fetchCRM(companyId, period).webFormSubmissions,
    webResponses:      fetchCRM(companyId, period).webFormResponses,
    smsInquiries:      fetchMessagingLogs(companyId, period).smsInbound,
    smsResponses:      fetchMessagingLogs(companyId, period).smsResponses,
    emailInquiries:    fetchCRM(companyId, period).emailInbound,
    emailResponses:    fetchCRM(companyId, period).emailResponses,
    avgResponseTimeMs: fetchCRMTimestamps(companyId, period).avgFirstResponse,
    qualifiedLeads:    fetchCRM(companyId, period).qualifiedCount,
    totalInquiries:    fetchCRM(companyId, period).totalInquiries,
    leadsWithFollowUp: fetchCRM(companyId, period).followedUpCount,
    unconvertedLeads:  fetchCRM(companyId, period).unconvertedCount,
    bookedAppts:       fetchScheduling(companyId, period).booked,
    noShows:           fetchScheduling(companyId, period).noShows,
    channelsUsed:      detectFollowUpChannels(companyId, period),
    hasMultiCriteria:  detectQualificationMethod(companyId),
    hasSelfService:    detectBookingMethod(companyId),
    industry:          fetchCompanyProfile(companyId).industry,
  };
}

function scoreCallAnswer(m: RawMetrics): number {
  const answerRate = (m.totalCalls - m.missedCalls) / m.totalCalls;
  const afterHoursCoverage = m.afterHoursAnswered / m.afterHoursCalls;
  const afterHoursPenalty = afterHoursCoverage >= 0.95 ? 1.0
                         : afterHoursCoverage >= 0.70 ? 0.85
                         : 0.65;
  return clamp(100 * answerRate * afterHoursPenalty, 0, 100);
}

function scoreResponseTime(m: RawMetrics): number {
  // Exponential decay: half-life = 10 minutes
  const avgMinutes = m.avgResponseTimeMs / 60000;
  const k = 0.0693; // ln(2) / 10
  return clamp(100 * Math.exp(-k * avgMinutes), 0, 100);
}

function scoreQualification(m: RawMetrics): number {
  const qualRate = m.qualifiedLeads / m.totalInquiries;
  const depthFactor = m.hasMultiCriteria ? 1.0
                    : m.hasQualification ? 0.75
                    : 0.50;
  return clamp(100 * qualRate * depthFactor, 0, 100);
}

function scoreFollowUp(m: RawMetrics): number {
  const followUpRate = m.leadsWithFollowUp / m.unconvertedLeads;
  const channelMult = m.channelsUsed >= 3 ? 1.0
                    : m.channelsUsed >= 2 ? 0.80
                    : m.channelsUsed >= 1 ? 0.60
                    : 0.40;
  return clamp(100 * followUpRate * channelMult, 0, 100);
}

function scoreScheduling(m: RawMetrics): number {
  const conversionRate = m.bookedAppts / m.qualifiedLeads;
  const showRate = 1 - (m.noShows / m.bookedAppts);
  const bookingFactor = m.hasSelfService ? 1.0
                      : m.hasMixedBooking ? 0.85
                      : m.hasPhoneBooking ? 0.65
                      : 0.50;
  return clamp(100 * conversionRate * showRate * bookingFactor, 0, 100);
}

const INDUSTRY_WEIGHTS: Record<string, Weights> = {
  "behavioral-health": { c: 0.35, r: 0.20, q: 0.20, f: 0.15, s: 0.10 },
  "home-healthcare":   { c: 0.30, r: 0.25, q: 0.20, f: 0.15, s: 0.10 },
  "medical-practice":  { c: 0.25, r: 0.20, q: 0.15, f: 0.15, s: 0.25 },
  "legal":             { c: 0.30, r: 0.25, q: 0.25, f: 0.10, s: 0.10 },
  "hvac":              { c: 0.35, r: 0.30, q: 0.10, f: 0.15, s: 0.10 },
  "plumbing":          { c: 0.35, r: 0.30, q: 0.10, f: 0.15, s: 0.10 },
  "electrical":        { c: 0.35, r: 0.30, q: 0.10, f: 0.15, s: 0.10 },
  "roofing":           { c: 0.25, r: 0.25, q: 0.20, f: 0.20, s: 0.10 },
  "real-estate":       { c: 0.25, r: 0.30, q: 0.15, f: 0.15, s: 0.15 },
  "saas":              { c: 0.10, r: 0.20, q: 0.25, f: 0.25, s: 0.20 },
  "insurance":         { c: 0.20, r: 0.25, q: 0.25, f: 0.20, s: 0.10 },
  "financial-services":{ c: 0.15, r: 0.20, q: 0.30, f: 0.20, s: 0.15 },
  "enterprise":        { c: 0.25, r: 0.20, q: 0.15, f: 0.15, s: 0.10 },
};
const DEFAULT_WEIGHTS = { c: 0.30, r: 0.25, q: 0.20, f: 0.15, s: 0.10 };

function getWeights(industry: string): Weights {
  return INDUSTRY_WEIGHTS[industry] || DEFAULT_WEIGHTS;
}

interface RRSResult {
  score: number;            // 0-100 composite
  tier: string;             // "Leader" | "Strong" | "Moderate" | "At Risk" | "Critical"
  subScores: SubScores;     // Individual factor scores
  weights: Weights;         // Applied weights
  industry: string;         // Industry used for normalization
}

interface SubScores {
  callAnswer: number;       // C — Missed Call Recovery, 0-100
  responseTime: number;     // R — Response Time Velocity, 0-100
  qualification: number;    // Q — Lead Qualification Rate, 0-100
  followUp: number;         // F — Follow-Up Completion, 0-100
  scheduling: number;       // S — Appointment Conversion, 0-100
}

function computeRRS(companyId: string): RRSResult {
  const m = collectMetrics(companyId);
  const weights = getWeights(m.industry);

  const subScores: SubScores = {
    callAnswer:    scoreCallAnswer(m),
    responseTime:  scoreResponseTime(m),
    qualification: scoreQualification(m),
    followUp:      scoreFollowUp(m),
    scheduling:    scoreScheduling(m),
  };

  const score = clamp(
    subScores.callAnswer    * weights.c +
    subScores.responseTime  * weights.r +
    subScores.qualification * weights.q +
    subScores.followUp      * weights.f +
    subScores.scheduling    * weights.s,
    0, 100
  );

  return {
    score: Math.round(score),
    tier: classifyTier(score),
    subScores,
    weights,
    industry: m.industry,
  };
}

function classifyTier(score: number): string {
  if (score >= 90) return "Revenue Recovery Leader";
  if (score >= 75) return "Strong Performer";
  if (score >= 50) return "Moderate Leakage";
  if (score >= 25) return "At Risk";
  return "Critical";
}

function clamp(value: number, min: number, max: number): number {
  return Math.max(min, Math.min(max, value));
}

function computeMultiLocationRRS(locationIds: string[]): MultiLocationResult {
  const results = locationIds.map(id => computeRRS(id));

  return {
    enterpriseScore: weightedAverage(results, "revenue"),  // Revenue-weighted
    locationScores: results,
    best: results.reduce((a, b) => a.score > b.score ? a : b),
    worst: results.reduce((a, b) => a.score < b.score ? a : b),
    variance: calculateVariance(results),
    atRiskLocations: results.filter(r => r.score < 50),
  };
}