Verification and readiness

/**
 * One call reads the provider through the attachment's session and the public pool through
 * `Resolver`, stores readiness per requirement, and says when to look again.
 */
export const check = Effect.map(Verify.observe({ domain }), (readiness) => ({
  ready: readiness.overall === "ready",
  nextCheckAt: readiness.nextCheckAt,
  pending: readiness.requirements
    .filter((requirement) => requirement.status !== "satisfied")
    .map((requirement) => `${requirement.record._tag} ${requirement.record.name}`),
}));

/** Requirements default to the latest apply receipt; pass a set to watch something else. */
export const watchOne = Verify.observe({
  domain,
  requirements: [DnsRecord.txt({ name: `_acme.${domain}`, value: "acme-verify=7f3a" })],
});

/**
 * Every requirement keeps the evidence behind its status, one entry per source that answered.
 * `values` is what that source returned for the record's name and type, empty when it returned
 * nothing; `detail` is null when satisfied and otherwise says what went wrong.
 */
export const sources = Effect.map(Verify.observe({ domain }), (readiness) =>
  readiness.requirements.flatMap((requirement) =>
    requirement.evidence.map((evidence) => ({
      record: requirement.record.name,
      status: requirement.status,
      source:
        evidence._tag === "Provider"
          ? evidence.provider
          : evidence._tag === "PublicDns"
            ? evidence.resolver
            : evidence.source,
      found: evidence._tag === "Host" ? [] : evidence.values,
      detail: evidence.detail,
    })),
  ),
);

/** Merge what only your app can see — an email identity, a certificate — without re-reading DNS. */
export const recordCertificate = Effect.gen(function* () {
  const observedAt = yield* DateTime.now;
  return yield* Verify.attachEvidence({
    domain,
    evidence: [
      new Verify.HostEvidence({
        source: "edge-certificate",
        status: "pending",
        label: "TLS certificate",
        detail: "Issuance starts once the CNAME resolves",
        observedAt,
      }),
    ],
  });
});

/** Quorum and the backoff ladder are references with defaults; override either per call tree. */
export const strict = check.pipe(
  Effect.provideService(Verify.Policy, {
    ...Verify.defaults,
    quorum: "all",
    backoff: (pendingForMs) => (pendingForMs < 60_000 ? 5_000 : 60_000),
  }),
);

/** Readiness carries its own schedule, so a worker sleeps until `nextCheckAt` instead of polling. */
export const dueAt = Effect.map(
  Verify.latest(domain),
  (readiness) => readiness?.nextCheckAt ?? null,
);

/**
 * `Verify.Observer` fires once per stored readiness, after the write. It is the one place a host
 * learns that DomainKit wrote readiness, so a projection lives here instead of beside every call
 * that might have caused one. The observer is bound to the layer rather than to one request, so
 * the event names the tenant it was written for: key the transition by `ownerId` and `domain`,
 * because the same domain can be attached in two tenants at once.
 */
const observer = Layer.succeed(Verify.Observer, {
  readinessChanged: ({ cause, domain, ownerId, readiness }) =>
    Effect.gen(function* () {
      if (readiness.overall === "ready") return yield* markReady({ ownerId, domain });
      // A pending domain carries its own schedule, so the host sleeps on it rather than polling.
      // Merged host evidence keeps the schedule an observation already set; before the first
      // observation there is none, so evidence on a row with no requirements schedules it.
      const schedules = cause === "observe" || readiness.requirements.length === 0;
      if (readiness.nextCheckAt !== null && schedules) {
        yield* wake({
          ownerId,
          domain,
          at: new Date(DateTime.toEpochMillis(readiness.nextCheckAt)),
        });
      }
    }),
});

export const live = DomainKit.layer({ providers }).pipe(Layer.provideMerge(observer));

/**
 * The clock is the host's. A job observes the domains that are due, and the observer above is what
 * tells the rest of the application that something changed. A domain with nothing to observe (no
 * receipt and no requirements) is logged and skipped, so it does not stop the batch; any other
 * failure fails the job, so your queue retries it.
 */
export const sweep = Effect.gen(function* () {
  const due = yield* domainsDue;
  yield* Effect.forEach(
    due,
    (domain) =>
      Verify.observe({ domain }).pipe(
        Effect.catch((error) =>
          error.reason._tag === "InvalidInput"
            ? Effect.logWarning(`nothing to observe for ${domain}`, error)
            : Effect.fail(error),
        ),
      ),
    { concurrency: 8 },
  );
}).pipe(Effect.provideService(Principal.Service, principal));

/**
 * A page or an API answers from the stored fact. `Verify.latest` reads it without observing, and
 * `Verify.summary` counts it, so nothing about the domain is decided twice.
 */
export const snapshot = (domain: string) =>
  Effect.map(Verify.latest(domain), (readiness) => ({
    readiness,
    ...Verify.summary(readiness),
  }));

/**
 * The host owns the clock: it reads the stored readiness on its own schedule, and the flow renders
 * what it was given. Nothing observes on mount, no timer runs, and `observe` and `retry` on the
 * surface ask the host for a fresh reading.
 */
function HostObservedSetup({ domain }: { readonly domain: string }) {
  const [readiness, setReadiness] = useState<Verify.Readiness | null>(null);
  const refresh = useCallback(() => {
    void api.verification?.latest(domain).then(setReadiness);
  }, [domain]);
  useEffect(refresh, [refresh]);

  const flow = Domain.useFlow({
    domain,
    requirements,
    verification: { readiness, observe: refresh },
  });
  const counts = Verify.summary(flow.readiness);
  return (
    <section>
      <p>{counts.observed ? `${counts.satisfied} of ${counts.total} found` : "Not checked yet"}</p>
      <table>
        <tbody>
          {flow.requirements.map((record) => {
            // Two facts, two columns: what a pending plan will do, and what was read back.
            const standing = Records.standingOf(record, {
              plan: flow.plan,
              readiness: flow.readiness,
            });
            return (
              <tr key={Records.identity(record)}>
                <td>{record.name}</td>
                <td>{standing.planned === null ? null : standing.planned._tag}</td>
                <td>{standing.observed?.status ?? "not checked"}</td>
              </tr>
            );
          })}
        </tbody>
      </table>
      <button onClick={() => flow.verification.observe()} type="button">
        Check again
      </button>
    </section>
  );
}

export function HostObserved({ domain }: { readonly domain: string }) {
  return (
    <DomainKit.Root transport={transport}>
      <HostObservedSetup domain={domain} />
    </DomainKit.Root>
  );
}