import type * as interfaces from '../ts_interfaces/index.js';

/**
 * The Accounts screen as data.
 *
 * Everything the screen says is decided here, from the controller's projection and the import
 * report alone: the browser holds no account state of its own, keeps no uncertainty flag and runs
 * no timer, so a failed read can never leave a view locked -- the next projection replaces the
 * whole screen. One exported function per state of the design's state table gives every state a
 * name, and the element renders those names.
 *
 * Vocabulary rule from the design review: the screen says Account, Used for and Used by. It never
 * says grant, binding, epoch, generation, authority or authswitch.
 */

type TAccount = interfaces.TControllerAccount;
type TLogin = interfaces.TControllerAccountLogin;
type TBinding = interfaces.TControllerAccountBinding;
type TImportSource = interfaces.TControllerAccountsImportSource;

/** How loud a value is. The element maps it to catalog badge types; no colour is decided here. */
export type TAccountsTone = 'neutral' | 'positive' | 'attention' | 'critical';

/** What AGL has of the accounts service. `pending` is the moment before the first answer. */
export type TAccountsRead =
  | { state: 'pending' }
  | { state: 'answered'; projection: interfaces.IControllerAuthorityProjection }
  | { state: 'failed'; message: string };

/** What the import pane has. Its read is taken on demand, so it has the same three outcomes. */
export type TAccountsImportRead =
  | { state: 'pending' }
  | { state: 'answered'; result: interfaces.TControllerAccountsImportInventoryResult }
  | { state: 'failed'; message: string };

/**
 * How the accounts service stands, in the vocabulary the Stats screen already uses: a value is
 * current, last known with a time, or unavailable.
 */
export type TAccountsServiceState =
  | 'current'
  | 'reading'
  | 'connecting'
  | 'unavailable'
  | 'incompatible';

export interface IAccountsServiceStatus {
  state: TAccountsServiceState;
  /** `Current`, `Last known 14:02:11`, or `Unavailable`. */
  freshness: string;
  /** The state as a sentence. Empty while the service is current and there is nothing to say. */
  headline: string;
  /** What the state means for running work. Empty when the headline is. */
  consequence: string;
  /** Whether shown values are a retained snapshot, which the element renders dimmed. */
  dimmed: boolean;
  /** Why the service itself blocks every action. Empty while it is current. */
  blockedReason: string;
}

export type TAccountsListState = 'unavailable' | 'empty' | 'complete' | 'partial';

export interface IAccountsList {
  state: TAccountsListState;
  rows: IAccountRow[];
  /** Removed accounts, kept behind a disclosure: a removal is often why a project lost access. */
  removedRows: IAccountRow[];
  /** The empty sentence, or the partial-list sentence. Empty for a complete, non-empty list. */
  notice: string;
}

/** Every account action the screen offers a slot for. */
export type TAccountActionId = 'add' | 'rename' | 'remove' | 'reauthenticate' | 'bind' | 'preuse';

/**
 * An action the screen shows but cannot run.
 *
 * The slot is rendered as a visible, disabled button with its reason in view rather than removed
 * from the screen, so a state never silently loses a control: a missing button is indistinguishable
 * from a state nobody thought about. `reason` is always set in this release, because this release
 * changes nothing about an account.
 */
export interface IAccountActionSlot {
  id: TAccountActionId;
  label: string;
  icon: string;
  reason: string;
}

export interface IAccountStatus {
  text: string;
  tone: TAccountsTone;
}

/** One login of an account: what it is used for, who manages it, and what it needs. */
export type TAccountLoginState =
  | 'ready'
  | 'refreshing'
  | 'retryWait'
  | 'needsReauth'
  | 'unverified'
  | 'pendingHandoff'
  | 'quarantined'
  | 'nativeOwned'
  | 'removed';

export interface IAccountLoginView {
  id: string;
  state: TAccountLoginState;
  /** "Used for": what this login signs in to, in the user's words. */
  purposeLabel: string;
  /** The short form for a chip. */
  chipText: string;
  tone: TAccountsTone;
  /** The state as a sentence. */
  statusText: string;
  /** Why it is in that state, when the service reports one. Empty otherwise. */
  causeText: string;
  /** "AGL Accounts" or the tool that owns the login. Never the word owner. */
  managedBy: string;
  /** When the service will try again by itself. */
  retryText: string;
  /**
   * When the accounts service renews this login next. It is a diagnostic and is labelled as one:
   * read as "access expires" it sounds like the user's own sign-in is about to end, which it is not.
   */
  renewalText: string;
  /** When the service last looked at this login. */
  observedText: string;
  actions: IAccountActionSlot[];
  /**
   * Slots that belong in the collapsed diagnostics rather than beside the login.
   *
   * Testing a login spends real provider quota, so it is a diagnostic tool and is kept where a
   * diagnostic tool belongs; a first-class button next to a sign-in gets pressed by accident.
   */
  diagnosticActions: IAccountActionSlot[];
}

export interface IAccountBindingView {
  id: string;
  /** "Used by": the harness, in the word the New-conversation form uses. */
  harnessLabel: string;
  /** The project's own name when AGL knows it, otherwise the id the service reported. */
  scopeLabel: string;
}

export interface IAccountRow {
  id: string;
  label: string;
  emailText: string;
  planText: string;
  removed: boolean;
  status: IAccountStatus;
  usedFor: IAccountLoginView[];
  usedBy: IAccountBindingView[];
  /** The list's one-line "Used by" column. */
  usedBySummary: string;
  actions: IAccountActionSlot[];
}

export type TImportPaneState = 'unavailable' | 'pending' | 'empty' | 'listed' | 'failed';

export interface IImportSourceRow {
  id: string;
  kindLabel: string;
  identityLabel: string;
  treatmentLabel: string;
  treatmentDetail: string;
  statusLabel: string;
  problems: string[];
}

export interface IImportPane {
  state: TImportPaneState;
  /** The state as a sentence, for every state that lists nothing. */
  notice: string;
  /** What the accounts service wants known before anything is moved. */
  noticeLines: string[];
  sources: IImportSourceRow[];
  /** Locations that could not be read, so an empty list never looks like an empty host. */
  problems: string[];
}

export interface IAccountsView {
  service: IAccountsServiceStatus;
  list: IAccountsList;
  /** The screen-level slots. Adding an account is the only one. */
  actions: IAccountActionSlot[];
}

/**
 * The sentence this release owes its readers: both surfaces exist, and this one does not sign
 * anyone in yet.
 */
export const accountsMovingNotice =
  'Accounts are moving here. Flex logins are still managed in Flex settings until the move.';

/** Why no action runs in this release. It names where the same work is done today. */
const readOnlyReleaseReason =
  'Accounts are read-only here in this AGL version; sign-ins are still made in Flex settings.';

const clockTime = (isoArg: string | null): string => {
  if (!isoArg) return '';
  const parsed = Date.parse(isoArg);
  return Number.isFinite(parsed) ? new Date(parsed).toLocaleTimeString() : '';
};

/** What a state says about itself: what it is, and what it means for work that is running. */
interface IServiceCopy {
  headline: string;
  consequence: string;
}

/** The state table's "daemon absent" row. The reason separates a host that never had it from one it is down on. */
const unavailableCopy = (
  reasonArg: interfaces.TControllerAuthorityUnavailableReason | null,
): IServiceCopy => ({
  headline: reasonArg === 'not_installed'
    ? 'The accounts service is not installed on this host.'
    : 'The accounts service is not running.',
  consequence: 'Running sessions keep access until their current token expires;'
    + ' sign-ins and renewals are paused.',
});

/** The state table's "connecting" row: an attempt is in flight, which is not yet an absence. */
const connectingCopy = (): IServiceCopy => ({
  headline: 'Connecting to the accounts service…',
  consequence: 'Accounts appear as soon as it answers.',
});

/** The first paint, before the controller has answered at all. */
const readingCopy = (): IServiceCopy => ({
  headline: 'Reading accounts…',
  consequence: '',
});

/** The state table's "incompatible" row. Retrying cannot help, so it is never a connection error. */
const incompatibleCopy = (): IServiceCopy => ({
  headline: 'This AGL version cannot read the accounts service on this host.',
  consequence: 'Update AGL to read it; retrying changes nothing.',
});

/** A read the controller itself did not answer. The next one replaces it; nothing stays stuck. */
const readFailedCopy = (messageArg: string): IServiceCopy => ({
  headline: 'Accounts could not be read from AGL.',
  consequence: messageArg,
});

const serviceCopy = (
  stateArg: TAccountsServiceState,
  reasonArg: interfaces.TControllerAuthorityUnavailableReason | null,
): IServiceCopy => {
  switch (stateArg) {
    // A current service needs no banner: the freshness line already says everything about it.
    case 'current': return { headline: '', consequence: '' };
    case 'reading': return readingCopy();
    case 'connecting': return connectingCopy();
    case 'incompatible': return incompatibleCopy();
    case 'unavailable': return unavailableCopy(reasonArg);
  }
};

const serviceStateOf = (
  projectionArg: interfaces.IControllerAuthorityProjection,
): TAccountsServiceState => {
  switch (projectionArg.state) {
    case 'ready': return 'current';
    case 'connecting': return 'connecting';
    case 'incompatible': return 'incompatible';
    case 'absent': return 'unavailable';
  }
};

const serviceBlockedReason = (stateArg: TAccountsServiceState): string => {
  switch (stateArg) {
    case 'current': return '';
    case 'reading': return 'AGL has not read the accounts service yet.';
    case 'connecting': return 'AGL is still connecting to the accounts service.';
    case 'unavailable': return 'The accounts service is not answering.';
    case 'incompatible': return 'This AGL version cannot read the accounts service.';
  }
};

/** How the service stands, and whether what the screen shows is current or last known. */
export const accountsServiceStatus = (readArg: TAccountsRead): IAccountsServiceStatus => {
  if (readArg.state !== 'answered') {
    const copy = readArg.state === 'pending' ? readingCopy() : readFailedCopy(readArg.message);
    const state: TAccountsServiceState = readArg.state === 'pending' ? 'reading' : 'unavailable';
    return {
      state,
      // A read that has not answered yet is neither current nor last known nor unavailable, and
      // claiming any of those three about it would be the one thing this vocabulary must not do.
      freshness: readArg.state === 'pending' ? 'Reading…' : 'Unavailable',
      headline: copy.headline,
      consequence: copy.consequence,
      dimmed: false,
      blockedReason: readArg.state === 'pending'
        ? serviceBlockedReason('reading')
        : 'AGL did not answer the accounts read.',
    };
  }
  const projection = readArg.projection;
  const state = serviceStateOf(projection);
  const retained = projection.snapshot !== null;
  const copy = serviceCopy(state, projection.reason);
  const lastKnown = clockTime(projection.lastVerifiedAt);
  return {
    state,
    freshness: state === 'current'
      ? 'Current'
      : retained && lastKnown ? `Last known ${lastKnown}` : 'Unavailable',
    headline: copy.headline,
    consequence: copy.consequence,
    dimmed: state !== 'current' && retained,
    blockedReason: serviceBlockedReason(state),
  };
};

/** "Used for": what a login signs in to. */
const purposeLabel = (loginArg: TLogin): string => {
  switch (loginArg.purpose) {
    case 'openai_managed': return 'ChatGPT sign-in';
    case 'claude_host_native': return 'Claude Code on this host';
    case 'claude_container_setup': return 'Claude Code in containers';
    case 'opencode_native': return 'OpenCode sign-in';
  }
};

/**
 * Which tool keeps a natively owned login.
 *
 * The purpose names it: the accounts service derives a Claude purpose from a Claude store, an
 * OpenCode purpose from OpenCode's, and leaves a natively owned ChatGPT login with Codex, which is
 * the only native tool that holds one.
 */
const nativeToolName = (loginArg: TLogin): string => {
  switch (loginArg.purpose) {
    case 'claude_host_native':
    case 'claude_container_setup': return 'Claude Code';
    case 'opencode_native': return 'OpenCode';
    case 'openai_managed': return 'Codex';
  }
};

const isNativelyOwned = (loginArg: TLogin): boolean => (
  loginArg.owner === 'claude_native' || loginArg.owner === 'legacy_native'
);

/** "Login managed by": one of two answers, never the word owner. */
const managedByLabel = (loginArg: TLogin): string => {
  if (loginArg.owner === 'daemon') return 'AGL Accounts';
  if (isNativelyOwned(loginArg)) return nativeToolName(loginArg);
  return 'No one until it is signed in again';
};

/** The state table's `needs_reauth` row: the cause, exactly as the service reports it. */
const loginCauseText = (loginArg: TLogin): string => {
  switch (loginArg.problem) {
    case 'none': return '';
    case 'provider_unavailable': return 'The provider could not be reached.';
    case 'exchange_uncertain': return 'A sign-in was interrupted and its outcome is unknown.';
    case 'provider_rejected': return 'The provider rejected the saved sign-in.';
    case 'native_owner': return 'Another tool on this host holds this login.';
  }
};

interface ILoginStateCopy {
  state: TAccountLoginState;
  chipText: string;
  statusText: string;
  tone: TAccountsTone;
}

/** The state table's "quarantined" row. A retry is never offered; only a fresh sign-in helps. */
const quarantinedCopy = (): ILoginStateCopy => ({
  state: 'quarantined',
  chipText: 'Needs a fresh sign-in',
  statusText: 'This login needs a fresh sign-in.',
  tone: 'critical',
});

/** The state table's "needs device login" row. */
const needsReauthCopy = (): ILoginStateCopy => ({
  state: 'needsReauth',
  chipText: 'Needs a new sign-in',
  statusText: 'This login needs a new sign-in.',
  tone: 'attention',
});

/** The state table's "native-owned" row: ownership, not health, and AGL says so. */
const nativeOwnedCopy = (loginArg: TLogin): ILoginStateCopy => ({
  state: 'nativeOwned',
  chipText: `Managed by ${nativeToolName(loginArg)}`,
  statusText: `Login managed by ${nativeToolName(loginArg)} · not monitored by AGL`,
  tone: 'neutral',
});

/** The state table's "daemon-owned" row, in each health the service reports for it. */
const daemonOwnedCopy = (loginArg: TLogin): ILoginStateCopy => {
  switch (loginArg.health) {
    case 'ready': return {
      state: 'ready', chipText: 'Ready', statusText: 'Ready to use.', tone: 'positive',
    };
    case 'refreshing': return {
      state: 'refreshing',
      chipText: 'Renewing',
      statusText: 'Renewing this login.',
      tone: 'neutral',
    };
    case 'retry_wait': return {
      state: 'retryWait',
      chipText: 'Waiting to retry',
      statusText: 'A renewal failed; the accounts service will try again by itself.',
      tone: 'attention',
    };
    case 'unverified': return {
      state: 'unverified',
      chipText: 'Not verified',
      statusText: 'This login has not been used since it was added, so nothing confirms it works.',
      tone: 'neutral',
    };
    case 'pending_handoff': return {
      state: 'pendingHandoff',
      chipText: 'Waiting for a handover',
      statusText: 'Waiting for the tool that holds this login to hand it over.'
        + ' It completes the next time that tool renews its own sign-in.',
      tone: 'neutral',
    };
    case 'removed': return {
      state: 'removed', chipText: 'Removed', statusText: 'This login was removed.', tone: 'neutral',
    };
    case 'needs_reauth': return needsReauthCopy();
    case 'handoff_quarantined': return quarantinedCopy();
  }
};

/**
 * Which row of the state table a login is on.
 *
 * What the user must do outranks who keeps the login: a quarantined or signed-out native login is
 * still the user's to repair, so those two are decided before ownership. Everything else a native
 * tool owns is reported as ownership, because AGL does not observe its health.
 */
const loginStateCopy = (loginArg: TLogin): ILoginStateCopy => {
  if (loginArg.health === 'handoff_quarantined') return quarantinedCopy();
  if (loginArg.health === 'needs_reauth') return needsReauthCopy();
  if (isNativelyOwned(loginArg)) return nativeOwnedCopy(loginArg);
  return daemonOwnedCopy(loginArg);
};

/** How much attention a login wants, so an account's chip can be its most demanding login. */
const loginSeverity = (stateArg: TAccountLoginState): number => {
  switch (stateArg) {
    case 'quarantined': return 5;
    case 'needsReauth': return 4;
    case 'retryWait': return 3;
    case 'pendingHandoff': return 2;
    case 'refreshing':
    case 'unverified': return 1;
    case 'nativeOwned':
    case 'ready':
    case 'removed': return 0;
  }
};

/**
 * Why an action the service does not offer for this login cannot run.
 *
 * Every branch reads a field of the login the service published -- who keeps it, what it is for,
 * how it stands -- so the sentence is the service's answer, never an AGL guess about it.
 */
const loginCapabilityReason = (loginArg: TLogin, actionArg: TAccountActionId): string => {
  if (isNativelyOwned(loginArg)) {
    return actionArg === 'bind'
      ? `${nativeToolName(loginArg)} manages this login, so projects cannot use it.`
      : `${nativeToolName(loginArg)} manages this login.`;
  }
  if (loginArg.health === 'removed') return 'This login was removed.';
  if (loginArg.purpose !== 'openai_managed') {
    return 'The accounts service offers this only for ChatGPT sign-ins.';
  }
  if (loginArg.health === 'refreshing') return 'This login is being renewed right now.';
  if (actionArg === 'bind') return 'A project can use this login once it is ready.';
  if (actionArg === 'preuse') return 'This login can be tested once it is ready.';
  return 'The accounts service does not offer a new sign-in for this login.';
};

const actionSlot = (
  idArg: TAccountActionId,
  labelArg: string,
  iconArg: string,
  reasonArg: string,
): IAccountActionSlot => ({ id: idArg, label: labelArg, icon: iconArg, reason: reasonArg });

/** A slot the service itself blocks, otherwise one this release blocks. */
const releaseBlockedSlot = (
  idArg: TAccountActionId,
  labelArg: string,
  iconArg: string,
  serviceArg: IAccountsServiceStatus,
): IAccountActionSlot => actionSlot(
  idArg, labelArg, iconArg, serviceArg.blockedReason || readOnlyReleaseReason,
);

/** A login slot: the service first, then what the service offers for this login, then the release. */
const loginActionSlot = (
  idArg: TAccountActionId,
  labelArg: string,
  iconArg: string,
  loginArg: TLogin,
  capableArg: boolean,
  serviceArg: IAccountsServiceStatus,
): IAccountActionSlot => actionSlot(
  idArg,
  labelArg,
  iconArg,
  serviceArg.blockedReason
    || (capableArg ? readOnlyReleaseReason : loginCapabilityReason(loginArg, idArg)),
);

const loginView = (
  loginArg: TLogin,
  serviceArg: IAccountsServiceStatus,
): IAccountLoginView => {
  const copy = loginStateCopy(loginArg);
  const retryAt = clockTime(loginArg.retryAt);
  return {
    id: loginArg.id,
    state: copy.state,
    purposeLabel: purposeLabel(loginArg),
    chipText: copy.chipText,
    tone: copy.tone,
    statusText: copy.statusText,
    causeText: loginCauseText(loginArg),
    managedBy: managedByLabel(loginArg),
    retryText: copy.state === 'retryWait' ? (retryAt ? `Next attempt ${retryAt}` : 'None scheduled') : '',
    renewalText: clockTime(loginArg.accessExpiresAt) || 'Not reported',
    observedText: clockTime(loginArg.statusObservedAt) || 'Not reported',
    actions: [
      loginActionSlot(
        'reauthenticate', 'Sign in again', 'lucide:LogIn',
        loginArg, loginArg.capabilities.canReauthenticate, serviceArg,
      ),
      loginActionSlot(
        'bind', 'Use for a project', 'lucide:Link',
        loginArg, loginArg.capabilities.canBind, serviceArg,
      ),
    ],
    diagnosticActions: [
      loginActionSlot(
        'preuse', 'Test this login', 'lucide:Stethoscope',
        loginArg, loginArg.capabilities.canPreuse, serviceArg,
      ),
    ],
  };
};

const harnessLabel = (bindingArg: TBinding): string => {
  switch (bindingArg.runtime) {
    case 'flex': return 'Flex';
    case 'codex': return 'Codex';
    case 'opencode': return 'OpenCode';
    case 'claude': return 'Claude Code';
  }
};

const bindingView = (
  bindingArg: TBinding,
  projectNamesArg: ReadonlyMap<string, string>,
): IAccountBindingView => ({
  id: bindingArg.id,
  harnessLabel: harnessLabel(bindingArg),
  scopeLabel: projectNamesArg.get(bindingArg.scopeId) ?? bindingArg.scopeId,
});

/** The account's chip: its most demanding login, so a row never looks calmer than its parts. */
const accountStatus = (
  accountArg: TAccount,
  loginsArg: readonly IAccountLoginView[],
): IAccountStatus => {
  if (accountArg.removed) return { text: 'Removed', tone: 'neutral' };
  if (loginsArg.length === 0) return { text: 'No logins yet', tone: 'neutral' };
  const worst = loginsArg.reduce((selectedArg, loginArg) => (
    loginSeverity(loginArg.state) > loginSeverity(selectedArg.state) ? loginArg : selectedArg
  ));
  return { text: worst.chipText, tone: worst.tone };
};

const usedBySummary = (bindingsArg: readonly IAccountBindingView[]): string => (
  bindingsArg.length === 0
    ? 'Not used by anything yet'
    : bindingsArg.map((bindingArg) => `${bindingArg.harnessLabel} · ${bindingArg.scopeLabel}`).join(', ')
);

const accountRow = (
  accountArg: TAccount,
  loginsArg: readonly TLogin[],
  bindingsArg: readonly TBinding[],
  projectNamesArg: ReadonlyMap<string, string>,
  serviceArg: IAccountsServiceStatus,
): IAccountRow => {
  const usedFor = loginsArg
    .filter((loginArg) => loginArg.accountId === accountArg.id)
    .map((loginArg) => loginView(loginArg, serviceArg));
  const usedBy = bindingsArg
    .filter((bindingArg) => bindingArg.accountId === accountArg.id)
    .map((bindingArg) => bindingView(bindingArg, projectNamesArg));
  return {
    id: accountArg.id,
    label: accountArg.label,
    emailText: accountArg.email ?? 'No email reported',
    planText: accountArg.plan ?? 'Plan not reported',
    removed: accountArg.removed,
    status: accountStatus(accountArg, usedFor),
    usedFor,
    usedBy,
    usedBySummary: usedBySummary(usedBy),
    actions: [
      releaseBlockedSlot('rename', 'Rename', 'lucide:PenLine', serviceArg),
      releaseBlockedSlot('remove', 'Remove', 'lucide:Trash2', serviceArg),
    ],
  };
};

/**
 * The account list.
 *
 * The rows and the sentence under them come from the same snapshot object, so a list that does not
 * end at its last row says so explicitly instead of looking like a host with no accounts.
 */
export const accountsList = (
  readArg: TAccountsRead,
  serviceArg: IAccountsServiceStatus,
  projectNamesArg: ReadonlyMap<string, string>,
): IAccountsList => {
  const snapshot = readArg.state === 'answered' ? readArg.projection.snapshot : null;
  if (!snapshot) return { state: 'unavailable', rows: [], removedRows: [], notice: '' };
  const rows = snapshot.accounts.map((accountArg) => accountRow(
    accountArg, snapshot.logins, snapshot.bindings, projectNamesArg, serviceArg,
  ));
  const listed = rows.filter((rowArg) => !rowArg.removed);
  const removedRows = rows.filter((rowArg) => rowArg.removed);
  // The partial verdict comes first: a first page that happens to be empty is still a list that
  // does not end here, and calling it "no accounts yet" is exactly the confusion this state exists
  // to prevent.
  if (snapshot.nextAccountCursor !== null) {
    return {
      state: 'partial',
      rows: listed,
      removedRows,
      notice: `Showing ${rows.length} accounts; the accounts service holds more than are listed here.`,
    };
  }
  if (rows.length === 0) {
    return { state: 'empty', rows: [], removedRows: [], notice: 'No accounts yet.' };
  }
  return { state: 'complete', rows: listed, removedRows, notice: '' };
};

/** The whole screen, from one projection and the projects AGL knows the names of. */
export const accountsView = (
  readArg: TAccountsRead,
  projectsArg: readonly interfaces.IControllerProject[],
): IAccountsView => {
  const service = accountsServiceStatus(readArg);
  const projectNames = new Map(projectsArg.map((projectArg) => [projectArg.id, projectArg.name]));
  return {
    service,
    list: accountsList(readArg, service, projectNames),
    actions: [releaseBlockedSlot('add', 'Add account', 'lucide:UserPlus', service)],
  };
};

const importKindLabel = (sourceArg: TImportSource): string => {
  switch (sourceArg.sourceKind) {
    case 'authswitch_stash': return 'Saved authswitch login';
    case 'authswitch_backup': return 'Authswitch backup';
    case 'agl_flex': return 'AGL Flex connection';
    case 'codex_native': return 'Codex sign-in';
    case 'opencode_native': return 'OpenCode sign-in';
    case 'claude_native': return 'Claude Code sign-in';
  }
};

/** What the ownership rule allows for one source, and what that means for the tool that holds it. */
const importTreatment = (
  sourceArg: TImportSource,
): { label: string; detail: string } => {
  switch (sourceArg.treatment) {
    case 'import': return {
      label: 'Moves to the accounts service',
      detail: 'The accounts service becomes the only renewer of this login.',
    };
    case 'project': return {
      label: 'Stays with its own tool',
      detail: 'The tool that holds it keeps renewing it; the accounts service only lists it.',
    };
    case 'refuse': return {
      label: 'Cannot be moved',
      detail: 'This login is signed in again instead of being moved.',
    };
  }
};

const importStatusLabel = (sourceArg: TImportSource): string => {
  switch (sourceArg.ledgerStatus) {
    case null: return 'Not submitted';
    case 'prepared': return 'Named, nothing sent';
    case 'pending_native_owner': return 'Waiting for its own tool';
    case 'verified': return 'Verified';
    case 'complete': return 'Moved';
    case 'quarantined': return 'Needs a fresh sign-in';
  }
};

const importSourceRow = (sourceArg: TImportSource): IImportSourceRow => {
  const treatment = importTreatment(sourceArg);
  return {
    id: sourceArg.id,
    kindLabel: importKindLabel(sourceArg),
    identityLabel: sourceArg.email ?? sourceArg.label ?? 'Identity not reported',
    treatmentLabel: treatment.label,
    treatmentDetail: treatment.detail,
    statusLabel: importStatusLabel(sourceArg),
    problems: sourceArg.problems,
  };
};

/** Why the pane has nothing to list, in the name of the state that caused it. */
const importUnavailableNotice = (
  daemonArg: interfaces.TControllerAuthorityDaemonState,
): string => {
  switch (daemonArg) {
    case 'absent': return 'The accounts service is not running, so this host\'s existing logins'
      + ' were not read.';
    case 'connecting': return 'AGL is still connecting to the accounts service.';
    case 'incompatible': return 'This AGL version cannot read the accounts service.';
    case 'ready': return 'The accounts service did not answer this read.';
  }
};

/**
 * The import pane: which logins this host already holds, and what would happen to each.
 *
 * Read-only in every sense -- the accounts service opens those stores, hashes what it finds and
 * answers with identity claims, and this AGL release offers no way to move any of them.
 */
export const importPane = (readArg: TAccountsImportRead): IImportPane => {
  if (readArg.state === 'pending') {
    return {
      state: 'pending',
      notice: 'Reading the logins this host already holds…',
      noticeLines: [],
      sources: [],
      problems: [],
    };
  }
  if (readArg.state === 'failed') {
    return {
      state: 'failed',
      notice: `The existing logins could not be read. ${readArg.message}`,
      noticeLines: [],
      sources: [],
      problems: [],
    };
  }
  if (readArg.result.state === 'unavailable') {
    return {
      state: 'unavailable',
      notice: importUnavailableNotice(readArg.result.daemon),
      noticeLines: [],
      sources: [],
      problems: [],
    };
  }
  const inventory = readArg.result.inventory;
  const sources = inventory.sources.map(importSourceRow);
  return {
    state: sources.length === 0 ? 'empty' : 'listed',
    notice: sources.length === 0 ? 'No existing logins were found on this host.' : '',
    noticeLines: inventory.notice,
    sources,
    problems: inventory.problems,
  };
};