AR Ticket Triager

// Parse inputs from Zapier
const names = inputData.names.split(",").map(n => n.trim());
const available = inputData.available.split(",").map(a => a.trim().toLowerCase() === "true");

// Map agent open ticket counts from individually named inputs
const openCounts = {
  "Agent1": parseInt(inputData.agent1_open, 10) || 0,
  "Agent2": parseInt(inputData.agent2_open, 10) || 0,
  "Agent3": parseInt(inputData.agent3_open, 10) || 0,
  "Agent4": parseInt(inputData.agent4_open, 10) || 0
};

// Get current hour in ET (timezone-aware)
const now = new Date();
const etHour = now.toLocaleString("en-US", {
  timeZone: "America/Toronto",
  hour: "numeric",
  hour12: false
});
const currentHour = parseInt(etHour, 10);

// Define working hours for each agent
const workingHours = {
  "Agent1": currentHour >= 4 && currentHour < 20,   // 4am-8pm ET
  "Agent2": true,  // Toronto-based, no restrictions
  "Agent3": true,   // Toronto-based, no restrictions
  "Agent4": true    // Toronto-based, no restrictions
};

// Build agent objects with availability and load data
const agents = names
  .filter(name => name !== "Agent5")  // Temporarily exclude Agent5
  .map((name, index) => ({
    name,
    available: available[names.indexOf(name)],
    openTickets: openCounts[name] ?? 0,
    inWorkingHours: workingHours[name] ?? true
  }));

// Filter for eligible agents (available AND within working hours)
const eligible = agents.filter(agent => agent.available && agent.inWorkingHours);

// Assignment logic with tie-breaking
let assignee = "NO_ONE_AVAILABLE";
let tied = [];
let reason = "";

if (eligible.length > 0) {
  const minOpen = Math.min(...eligible.map(a => a.openTickets));
  tied = eligible.filter(a => a.openTickets === minOpen);

  if (tied.length === 1) {
    assignee = tied[0].name;
    reason = `Assigned to ${assignee} with lowest load (${minOpen} open tickets)`;
  } else {
    // Random selection among tied agents
    const randomIndex = Math.floor(Math.random() * tied.length);
    assignee = tied[randomIndex].name;
    reason = `Randomly assigned among ${tied.length} agents tied at ${minOpen} open tickets`;
  }
} else {
  reason = "No agents available";
}

return {
  assignee,
  eligibleAgents: eligible.map(a => `${a.name}: ${a.openTickets} open`),
  tiedAtMin: tied.map(a => a.name),
  reason,
  currentHour: `${currentHour}:00 ET`
};

// Timezone-aware working hours validation
const isWithinWorkingHours = (agent, currentTime = new Date()) => {
  const agentTimezone = agent.timezone || 'UTC';
  const localTime = new Date(currentTime.toLocaleString("en-US", {timeZone: agentTimezone}));
  const localHour = localTime.getHours();
  const localDay = localTime.getDay(); // 0 = Sunday, 6 = Saturday
  
  // Weekend check
  if (localDay === 0 || localDay === 6) {
    return { 
      available: false, 
      reason: `Weekend in ${agentTimezone} (local time: ${localTime.toLocaleString()})` 
    };
  }
  
  // Working hours check (9 AM - 5 PM local time)
  if (localHour < 9 || localHour >= 17) {
    return { 
      available: false, 
      reason: `Outside working hours in ${agentTimezone} (local time: ${localTime.toLocaleString()})` 
    };
  }
  
  return { available: true, reason: "Within working hours" };
};

// Enhanced agent filtering with detailed reasoning
const filterAvailableAgents = (agents) => {
  const results = {
    available: [],
    filtered: [],
    summary: {}
  };
  
  agents.forEach(agent => {
    const timeCheck = isWithinWorkingHours(agent);
    const statusCheck = agent.status === 'available';
    const oooCheck = !agent.ooo_until || new Date(agent.ooo_until) <= new Date();
    
    if (timeCheck.available && statusCheck && oooCheck) {
      results.available.push(agent);
    } else {
      results.filtered.push({
        agent: agent.name,
        reasons: [
          !timeCheck.available ? timeCheck.reason : null,
          !statusCheck ? "Marked as unavailable" : null,
          !oooCheck ? `OOO until ${agent.ooo_until}` : null
        ].filter(Boolean)
      });
    }
  });
  
  results.summary = {
    total_agents: agents.length,
    available_count: results.available.length,
    filtered_count: results.filtered.length
  };
  
  return results;
};