import * as plugins from './plugins.js';
import type { IControllerCodexModelChoice } from '../ts_interfaces/index.js';
import { isCodexCreationToken, isCodexThreadId } from './functions.codexidentity.js';
import { codexQualifiedIdentity, isCodexSessionId } from './functions.codexidentity.js';
import { assertCodexOrigin, isCodexRemoteDirectory, type IControllerCodexOrigin } from './classes.codexconnectionmodels.js';
export { isCodexCreationToken, isCodexThreadId } from './functions.codexidentity.js';

export interface ICodexOwnedProcessIdentity {
  pid: number;
  processGroupId: number;
  fingerprint: string;
}

export interface ICodexCreationRuntime {
  generation: string;
  /** Absent for an externally managed server: disconnect never proves that server exited. */
  process?: ICodexOwnedProcessIdentity;
}

export type TCodexCreationState = 'pending' | 'dispatched' | 'bound' | 'admitted' | 'materialized' | 'retired';

export interface IControllerCodexCreationDocument {
  /** Selected server/cwd are reserved before dispatch; native origin is completed on bind. */
  connection?: { profileId: string; remoteDirectory: string };
  codexOrigin?: IControllerCodexOrigin;
  id: string;
  issuerId: string;
  projectIdentityId: string;
  operationId: string;
  state: TCodexCreationState;
  title: string;
  model?: IControllerCodexModelChoice;
  requestedAt: Date;
  updateId: string;
  runtime?: ICodexCreationRuntime;
  dispatchedAt?: Date;
  nativeId?: string;
  providerCreatedAt?: number;
  sessionIdentityId?: string;
  /** Initial title and model were applied before any user mutation or first turn. */
  metadataFinalizedAt?: Date;
  /** A first turn may have executed even if its response was lost. */
  turnDispatchedAt?: Date;
  terminalAt?: Date;
}

const isRecord = (valueArg: unknown): valueArg is Record<string, unknown> => (
  typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg)
  && (Object.getPrototypeOf(valueArg) === Object.prototype || Object.getPrototypeOf(valueArg) === null)
);
const exactKeys = (valueArg: Record<string, unknown>, requiredArg: string[], optionalArg: string[] = []): boolean => (
  requiredArg.every((key) => Object.hasOwn(valueArg, key))
  && Object.keys(valueArg).every((key) => requiredArg.includes(key) || optionalArg.includes(key))
);
const isDate = (valueArg: unknown): valueArg is Date => (
  valueArg instanceof Date && Number.isFinite(valueArg.getTime()) && valueArg.getTime() >= 0
);

export const codexCreationDocumentId = (
  issuerIdArg: string,
  projectIdArg: string,
  operationIdArg: string,
): string => {
  if (!isCodexCreationToken(issuerIdArg, 32) || !isCodexCreationToken(projectIdArg, 16)
    || !isCodexCreationToken(operationIdArg, 24)) throw new Error('Invalid Codex creation scope.');
  return plugins.crypto.createHash('sha256')
    .update(JSON.stringify(['codex-creation-v1', issuerIdArg, projectIdArg, operationIdArg]))
    .digest('base64url');
};

export const assertCodexCreationRuntime: (valueArg: unknown) => asserts valueArg is ICodexCreationRuntime = (valueArg) => {
  if (!isRecord(valueArg) || !exactKeys(valueArg, ['generation'], ['process'])
    || !isCodexCreationToken(valueArg.generation, 32)) throw new Error('Invalid Codex creation runtime.');
  if (Object.hasOwn(valueArg, 'process')) {
    const identity = valueArg.process;
    if (!isRecord(identity) || !exactKeys(identity, ['pid', 'processGroupId', 'fingerprint'])
      || !Number.isSafeInteger(identity.pid) || Number(identity.pid) < 2
      || identity.processGroupId !== identity.pid
      || typeof identity.fingerprint !== 'string' || identity.fingerprint.length < 8
      || identity.fingerprint.length > 256 || /[\u0000-\u001f\u007f]/.test(identity.fingerprint)) {
      throw new Error('Invalid owned Codex process identity.');
    }
  }
};

export const assertControllerCodexCreationDocument: (
  valueArg: unknown,
) => asserts valueArg is IControllerCodexCreationDocument = (valueArg) => {
  if (!isRecord(valueArg) || !exactKeys(valueArg,
    ['id', 'issuerId', 'projectIdentityId', 'operationId', 'state', 'title', 'requestedAt', 'updateId'],
    ['model', 'runtime', 'dispatchedAt', 'nativeId', 'providerCreatedAt', 'sessionIdentityId', 'metadataFinalizedAt', 'turnDispatchedAt', 'terminalAt', 'connection', 'codexOrigin'])
    || !isCodexCreationToken(valueArg.issuerId, 32)
    || !isCodexCreationToken(valueArg.projectIdentityId, 16)
    || !isCodexCreationToken(valueArg.operationId, 24)
    || valueArg.id !== codexCreationDocumentId(valueArg.issuerId, valueArg.projectIdentityId, valueArg.operationId)
    || !isCodexCreationToken(valueArg.updateId, 32)
    || !['pending', 'dispatched', 'bound', 'admitted', 'materialized', 'retired'].includes(String(valueArg.state))
    || typeof valueArg.title !== 'string' || valueArg.title.trim().length === 0
    || valueArg.title.length > 2048 || !isDate(valueArg.requestedAt)) {
    throw new Error('Invalid Codex creation intent.');
  }
  if (Object.hasOwn(valueArg, 'model')) {
    const model = valueArg.model;
    if (!isRecord(model) || !exactKeys(model, ['harnessId', 'providerID', 'modelID'], ['variant'])
      || model.harnessId !== 'codex' || model.providerID !== 'codex'
      || typeof model.modelID !== 'string' || model.modelID.trim().length === 0 || model.modelID.length > 512
      || (Object.hasOwn(model, 'variant') && (typeof model.variant !== 'string' || model.variant.length === 0 || model.variant.length > 128))) {
      throw new Error('Invalid Codex creation model.');
    }
  }
  const dispatched = Object.hasOwn(valueArg, 'dispatchedAt');
  const bound = Object.hasOwn(valueArg, 'nativeId');
  const admitted = Object.hasOwn(valueArg, 'sessionIdentityId');
  const terminal = Object.hasOwn(valueArg, 'terminalAt');
  if (dispatched !== Object.hasOwn(valueArg, 'runtime')
    || bound !== Object.hasOwn(valueArg, 'providerCreatedAt')
    || (bound && !dispatched) || (admitted && !bound)) throw new Error('Incomplete Codex creation facts.');
  if (dispatched) {
    assertCodexCreationRuntime(valueArg.runtime);
    if (!isDate(valueArg.dispatchedAt) || valueArg.dispatchedAt < valueArg.requestedAt) throw new Error('Invalid Codex dispatch time.');
  }
  if (bound && (!isCodexSessionId(valueArg.nativeId) || !Number.isSafeInteger(valueArg.providerCreatedAt)
    || Number(valueArg.providerCreatedAt) < 0)) throw new Error('Invalid Codex assigned identity.');
  if (Object.hasOwn(valueArg, 'connection')) {
    const connection = valueArg.connection;
    if (!isRecord(connection) || !exactKeys(connection, ['profileId', 'remoteDirectory'])
      || !isCodexCreationToken(connection.profileId, 32) || !isCodexRemoteDirectory(connection.remoteDirectory)) throw new Error('Invalid Codex creation connection.');
    if (bound) {
      assertCodexOrigin(valueArg.codexOrigin);
      const identity = codexQualifiedIdentity(valueArg.nativeId);
      if (connection.profileId !== valueArg.codexOrigin.profileId || connection.remoteDirectory !== valueArg.codexOrigin.remoteDirectory
        || (identity ? identity.profileId !== connection.profileId || identity.rawThreadId !== valueArg.codexOrigin.rawThreadId : valueArg.nativeId !== valueArg.codexOrigin.rawThreadId)) throw new Error('Codex creation changed its origin.');
    } else if (Object.hasOwn(valueArg, 'codexOrigin')) throw new Error('An unbound Codex creation cannot have a native origin.');
  } else if (Object.hasOwn(valueArg, 'codexOrigin') || codexQualifiedIdentity(valueArg.nativeId)) throw new Error('Codex origin requires its reserved connection.');
  if (admitted && !isCodexCreationToken(valueArg.sessionIdentityId, 32)) throw new Error('Invalid Codex managed identity.');
  const finalized = Object.hasOwn(valueArg, 'metadataFinalizedAt');
  if (finalized && (!admitted || !isDate(valueArg.metadataFinalizedAt)
    || valueArg.metadataFinalizedAt < (valueArg.dispatchedAt as Date))) throw new Error('Invalid Codex metadata finalization.');
  if (Object.hasOwn(valueArg, 'turnDispatchedAt') && (!finalized || !isDate(valueArg.turnDispatchedAt)
    || valueArg.turnDispatchedAt < (valueArg.metadataFinalizedAt as Date))) throw new Error('Invalid Codex first-turn dispatch.');
  if (terminal && (!isDate(valueArg.terminalAt) || valueArg.terminalAt < valueArg.requestedAt
    || (dispatched && valueArg.terminalAt < (valueArg.dispatchedAt as Date)))) throw new Error('Invalid Codex terminal time.');
  if ((valueArg.state === 'pending' && (dispatched || bound || admitted || terminal))
    || (valueArg.state === 'dispatched' && (!dispatched || bound || admitted || terminal))
    || (valueArg.state === 'bound' && (!bound || admitted || terminal))
    || (valueArg.state === 'admitted' && (!admitted || terminal))
    || (valueArg.state === 'materialized' && (!admitted || !finalized || !terminal))
    || (valueArg.state === 'retired' && !terminal)) throw new Error('Invalid Codex creation state.');
};

@plugins.smartdata.compoundIndex({
  name: 'controller_codex_creation_scope_state',
  key: { issuerId: 1, projectIdentityId: 1, state: 1, id: 1 },
})
@plugins.smartdata.compoundIndex({
  name: 'controller_codex_creation_native',
  key: { issuerId: 1, projectIdentityId: 1, nativeId: 1 },
})
@plugins.smartdata.managed({ collectionName: 'agl_controller_codex_creation_intents' })
@plugins.smartdata.exactPersistence({ assertDocument: assertControllerCodexCreationDocument })
export class ControllerCodexCreationModel extends plugins.smartdata.SmartDataDbDoc<
  ControllerCodexCreationModel, IControllerCodexCreationDocument
> {
  declare static exact: plugins.smartdata.TExact<ControllerCodexCreationModel>;
  @plugins.smartdata.svDb() public connection?: IControllerCodexCreationDocument['connection'];
  @plugins.smartdata.svDb() public codexOrigin?: IControllerCodexOrigin;
  @plugins.smartdata.unI() public id!: string;
  @plugins.smartdata.svDb() public issuerId!: string;
  @plugins.smartdata.svDb() public projectIdentityId!: string;
  @plugins.smartdata.svDb() public operationId!: string;
  @plugins.smartdata.svDb() public state!: TCodexCreationState;
  @plugins.smartdata.svDb() public title!: string;
  @plugins.smartdata.svDb() public model?: IControllerCodexModelChoice;
  @plugins.smartdata.svDb() public requestedAt!: Date;
  @plugins.smartdata.svDb() public updateId!: string;
  @plugins.smartdata.svDb() public runtime?: ICodexCreationRuntime;
  @plugins.smartdata.svDb() public dispatchedAt?: Date;
  @plugins.smartdata.svDb() public nativeId?: string;
  @plugins.smartdata.svDb() public providerCreatedAt?: number;
  @plugins.smartdata.svDb() public sessionIdentityId?: string;
  @plugins.smartdata.svDb() public metadataFinalizedAt?: Date;
  @plugins.smartdata.svDb() public turnDispatchedAt?: Date;
  @plugins.smartdata.index({ expireAfterSeconds: 30 * 24 * 60 * 60 }) public terminalAt?: Date;
}