// src/services/voiceDiag/checks/callWaiting.js
//
// Detects whether Call Waiting is enabled for the store user. Call
// waiting being *off* is uncommon in a store context — it means a
// second incoming call while the operator is on the phone will get a
// busy tone or hit the busy-forward target instead of showing a
// beep-in on the desk phone.
//
// Endpoint: GET/PUT /v1/people/{personId}/features/callWaiting
// Payload:  { enabled: boolean }
// Scope:    spark-admin:people_read (GET) + spark-admin:people_write (PUT).
//
// Severity: warn when disabled — we can't tell for sure it's a bug
// (some sites want it off), but for a store phone it's usually
// inadvertent. Remediation: turn call waiting back on.

import { logger } from '../../../utils/logger.js';
import { describeRequester } from '../../../utils/requester.js';

const ENDPOINT = (personId) =>
  `people/${personId}/features/callWaiting`;

export const callWaitingCheck = {
  id: 'callWaiting',
  label: 'Call Waiting',
  requires: ['personId'],
  scope: 'spark-admin:people_read',

  async run(ctx) {
    const data = await ctx.webex.request('GET', ENDPOINT(ctx.personId));
    const enabled = !!data?.enabled;

    if (enabled) {
      return {
        status: 'ok',
        message: 'Call waiting is on.',
        details: { enabled },
        remediation: null,
      };
    }

    return {
      status: 'warn',
      message:
        'Call waiting is disabled — a second inbound call will not beep in.',
      details: { enabled },
      remediation: {
        action: 'enable_call_waiting',
        title: 'Enable Call Waiting',
        summary: `Turn call waiting on for ${ctx.personLabel}.`,
        payload: {
          personId: ctx.personId,
          personLabel: ctx.personLabel,
          storeNum: ctx.storeNum,
          before: { enabled },
        },
      },
    };
  },

  remediations: {
    async enable_call_waiting(bot, data, requester) {
      const { personId, personLabel, storeNum, before } = data;

      logger(
        'voicediag:audit',
        `CONFIRMED enable_call_waiting for ${personLabel} (person=${personId}, store=${storeNum}) ` +
        `by ${describeRequester(requester)} — was enabled=${before?.enabled ?? 'unknown'}`,
      );

      try {
        const { default: webex } = await import('../../../integrations/webex/WebexClient.js');
        await webex.request('PUT', ENDPOINT(personId), { enabled: true });
      } catch (err) {
        logger(
          'voicediag:audit',
          `FAILED enable_call_waiting for ${personLabel}: ${err.message}`,
          'error',
        );
        await bot.say(
          'markdown',
          `❌ Failed to enable call waiting for **${personLabel}**: ${err.message}`,
        );
        return;
      }

      await bot.say(
        'markdown',
        `✅ Call waiting enabled for **${personLabel}** (store ${storeNum}). ` +
        `Re-run \`/voicediag ${storeNum}\` to verify.`,
      );
      logger(
        'voicediag:audit',
        `COMPLETED enable_call_waiting for ${personLabel} (store ${storeNum})`,
      );
    },
  },
};