import {
  controllerLiveToolPayloadNotice,
  controllerMaxToolEventBytes,
  type IControllerToolExecution,
} from '../ts_interfaces/index.js';

/**
 * A live tool snapshot as a harness adapter produces it, before the controller stamps its
 * delivery ordering on it. Both session harnesses that bound a live tool payload — OpenCode in
 * its event stream, Flex in the controller — hand exactly this shape to the bounder below.
 */
export type TLiveToolSnapshot = Omit<IControllerToolExecution, 'revision' | 'streamEpoch'>;

/**
 * What a bounded live tool snapshot must fit into. The headroom below
 * `controllerMaxToolEventBytes` covers the envelope the controller wraps the snapshot in — event
 * type, project and harness identity, timestamps, ordering — so the delivered event stays inside
 * the budget the browser admits.
 */
export const liveToolExecutionBudgetBytes = controllerMaxToolEventBytes - (8 * 1024);

/**
 * How much of an error text a bounded snapshot keeps. An error is a diagnosis, not a stream: its
 * first kilobytes carry the cause, and the durable transcript keeps the rest.
 */
const liveToolErrorTextBudgetBytes = 4 * 1024;

/** A text bounded to a byte budget, together with whether the bound actually cut it. */
export interface IBoundedToolText {
  /** A complete-UTF-8 prefix of the original, carrying no marker of its own. */
  text: string;
  truncated: boolean;
}

/**
 * Bound a text to a byte budget and say what happened, so no caller has to read the result back
 * to find out. The prefix is deliberately marker-free: a live payload is covered by the durable
 * one only while it remains a prefix of it, and a marker written into the value would make that
 * impossible for good. See `IControllerToolExecution` for the contract.
 */
export const boundToolText = (valueArg: string, byteLimitArg: number): IBoundedToolText => {
  if (Buffer.byteLength(valueArg, 'utf8') <= byteLimitArg) {
    return { text: valueArg, truncated: false };
  }
  return {
    text: Buffer.from(valueArg, 'utf8')
      .subarray(0, Math.max(0, byteLimitArg))
      .toString('utf8')
      .replace(/�$/u, ''),
    truncated: true,
  };
};

/**
 * Bound one live tool snapshot to the live event budget, giving up the least useful payload
 * first: a structured input, then the tail of an error text, then a structured output, and only
 * then the tail of the output stream the user is watching. Each step is followed by a fresh
 * measurement, so a snapshot only loses what it has to.
 *
 * Both bounding operations the contract allows are signalled out of band — an elided payload
 * becomes `controllerLiveToolPayloadNotice`, a truncated text becomes a marker-free prefix plus
 * its flag — because the receiver retires a live snapshot exactly when the durable tool call
 * covers it, and an in-band marker could never appear in the durable payload.
 *
 * `harnessNameArg` names the harness in the one error this can raise: a snapshot whose identity
 * alone exceeds the budget is a bug in the harness adapter, not something to send truncated.
 */
export const boundLiveToolExecution = (
  executionArg: TLiveToolSnapshot,
  harnessNameArg: string,
): TLiveToolSnapshot => {
  const result = { ...executionArg };
  const serializedBytes = () => Buffer.byteLength(JSON.stringify(result), 'utf8');
  if (serializedBytes() <= liveToolExecutionBudgetBytes) return result;

  // No prefix of a structured input is meaningful, so an input is sent whole or not at all.
  if (result.input !== undefined) result.input = controllerLiveToolPayloadNotice;
  if (serializedBytes() <= liveToolExecutionBudgetBytes) return result;

  if (typeof result.errorText === 'string') {
    const boundedErrorText = boundToolText(result.errorText, liveToolErrorTextBudgetBytes);
    result.errorText = boundedErrorText.text;
    if (boundedErrorText.truncated) result.errorTextTruncated = true;
  }
  if (serializedBytes() <= liveToolExecutionBudgetBytes) return result;

  if (result.output !== undefined && typeof result.output !== 'string') {
    result.output = controllerLiveToolPayloadNotice;
  }
  if (serializedBytes() <= liveToolExecutionBudgetBytes) return result;

  // The elision notice is a whole value, never a text to cut: a fragment of it would be neither the
  // sentinel the coverage rule recognises nor a prefix of any durable payload, so it could never
  // be retired.
  if (typeof result.output === 'string' && result.output !== controllerLiveToolPayloadNotice) {
    const originalOutput = result.output;
    // The whole output demonstrably does not fit, so the prefix found below is shorter than it.
    // The flag is raised before the search rather than after it, so every candidate is measured
    // with the bytes the flag itself costs and the fitted prefix cannot overshoot the budget.
    result.outputTruncated = true;
    let lowerBound = 0;
    let upperBound = Buffer.byteLength(originalOutput, 'utf8');
    let fittedOutput = '';
    while (lowerBound <= upperBound) {
      const candidateLimit = Math.floor((lowerBound + upperBound) / 2);
      const candidateOutput = boundToolText(originalOutput, candidateLimit).text;
      result.output = candidateOutput;
      if (serializedBytes() <= liveToolExecutionBudgetBytes) {
        fittedOutput = candidateOutput;
        lowerBound = candidateLimit + 1;
      } else {
        upperBound = candidateLimit - 1;
      }
    }
    result.output = fittedOutput;
  }
  if (serializedBytes() <= liveToolExecutionBudgetBytes) return result;

  throw new Error(`The ${harnessNameArg} live tool execution exceeded its transfer budget.`);
};