// Pure derivation for the practitioner-recommendation callout: fold the funnel's per-schedule
// data into one `BookablePractitioner` per distinct practitioner-role that offers the chosen service -
// ORG-WIDE, across every location. Location is NEVER used to prune here (that's the whole point: location
// frames the manual list but must never narrow the specialty ranker). It is used only to CHOOSE which
// site to display for a role that serves the service at more than one - via `preferLocationId`, the same
// tie-break handleScheduleChange uses (prefer the selected site, else the first). Kept pure + unit-tested
// so this non-trivial fold isn't buried in the stateful booking component.

import type { CodeableConcept, Reference } from 'fhir/r4';
import type { BookablePractitioner } from './matchPractitionerSuggestions';

// One booking "block" as the component already holds it (a service-matched Schedule resolved to its role,
// practitioner display, and the site(s) it serves that service at). Plain data - no FHIR traversal here.
export interface BookablePractitionerCandidate {
  // The org-scoped PractitionerRole id - the dedup + selection key. Candidates without one are skipped
  // (there is nothing stable to recommend or select).
  practitionerRoleId?: string;
  // The practitioner's display name - the SAME source the manual practitioner <Select> renders (the
  // Schedule's Practitioner actor `display`).
  display: string;
  // The role's specialty CodeableConcept(s); the first's `text || coding[0].display` becomes specialtyDisplay.
  specialty?: CodeableConcept[];
  // The location ref(s) this role serves the service at (the funnel's getScheduleLocationRefs output).
  locationRefs?: Array<Pick<Reference, 'reference' | 'display'>>;
}

const locationIdOf = (ref?: Pick<Reference, 'reference'>): string =>
  ref?.reference?.split('/').pop() ?? '';

const specialtyDisplayOf = (specialty?: CodeableConcept[]): string => {
  const first = specialty?.[0];
  return (first?.text || first?.coding?.[0]?.display || '').trim();
};

/**
 * WHICH specialty this is, for comparing two practitioners - never for showing anybody.
 *
 * `text` FIRST, and that order is a measured decision rather than a preference. Family Medicine
 * Physician and Hospitalist BOTH carry SNOMED 394814009 - whose preferred term is "General practice" -
 * so keying on the code alone collapses two genuinely different roles into one and the gate stays shut.
 * The writer populates `text` with the ROLE for exactly this reason.
 *
 * THE CODE IS THE FALLBACK, and it is what this function was added for: a specialty recorded as a bare
 * coding with no `display` and no `text` is still a specialty, and it is the more correct FHIR. Keying
 * on the label alone made such a clinician count as having none at all - measured at Great River, where
 * one of the two Consultation practitioners is held as SNOMED 394814009 with neither.
 *
 * Lower-cased so "Cardiology" and "cardiology" are not two specialties.
 */
const specialtyKeyOf = (specialty?: CodeableConcept[]): string => {
  const first = specialty?.[0];
  const text = (first?.text || '').trim();
  if (text) {
    return text.toLowerCase();
  }
  const coding = first?.coding?.[0];
  return coding?.code ? `${coding.system ?? ''}|${coding.code}` : '';
};

export function buildBookablePractitioners(
  candidates: BookablePractitionerCandidate[],
  opts: {
    // id -> org location name, to backfill a site label when the ref itself carries no display.
    locationNameById?: Map<string, string>;
    // Among the sites a role serves the service at, prefer this one for display (never prunes the role).
    preferLocationId?: string;
  } = {},
): BookablePractitioner[] {
  // Group every schedule-block by its role, preserving the order roles are first seen so the output is
  // stable/deterministic. Multiple blocks for one role (e.g. the same practitioner at two sites) collapse
  // into a single recommendation whose display-site is chosen below.
  const blocksByRole = new Map<string, BookablePractitionerCandidate[]>();
  const roleOrder: string[] = [];
  for (const candidate of candidates) {
    const roleId = candidate.practitionerRoleId;
    if (!roleId) continue; // nothing stable to recommend/select
    if (!blocksByRole.has(roleId)) {
      blocksByRole.set(roleId, []);
      roleOrder.push(roleId);
    }
    blocksByRole.get(roleId)!.push(candidate);
  }

  const out: BookablePractitioner[] = [];
  for (const roleId of roleOrder) {
    const blocks = blocksByRole.get(roleId)!;
    const first = blocks[0]; // display + specialty are role-level, identical across the role's blocks
    // All sites this role serves the service at; prefer the caller's site when the role serves it, else
    // the first. This is display-only - the role is included regardless of location.
    const siteRefs = blocks.flatMap((block) => block.locationRefs ?? []);
    const chosenRef =
      (opts.preferLocationId
        ? siteRefs.find((ref) => locationIdOf(ref) === opts.preferLocationId)
        : undefined) ?? siteRefs[0];
    const locationId = locationIdOf(chosenRef);
    const locationDisplay =
      chosenRef?.display ||
      (locationId ? opts.locationNameById?.get(locationId) : undefined) ||
      locationId ||
      '';

    out.push({
      practitionerRoleId: roleId,
      display: first.display,
      specialtyDisplay: specialtyDisplayOf(first.specialty),
      specialtyKey: specialtyKeyOf(first.specialty),
      locationId,
      locationDisplay,
    });
  }
  return out;
}