import * as plugins from './plugins.js';
import type { TControllerSessionId } from '../ts_interfaces/index.js';
import { flexSessionProviderGeneration } from './classes.sessionidentityintegration.js';
import { assertCodexOrigin, type IControllerCodexOrigin } from './classes.codexconnectionmodels.js';
import { codexQualifiedIdentity } from './functions.codexidentity.js';

const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
const maximumNativeIdBytes = 512;
const maximumProviderGenerationBytes = 512;

export const controllerFlexCleanupCohortLimit = 2_048;

export interface IControllerFlexCleanupEntry {
  sessionId: string;
  sessionGenerationId: string;
  sessionGenerationSequence: number;
  providerSessionGeneration: string;
  cleanupRoot: boolean;
}

export type TControllerManagedSessionState = 'active' | 'deleting' | 'retired';
export type TControllerManagedSessionAdmissionSource =
  | 'controller-created'
  | 'explicit-enrollment'
  | 'project-folder-discovery'
  | 'legacy-state-migration';

export interface IControllerManagedSessionDeletion {
  operationId: string;
  expectedBindingId: string;
  supervisorGeneration: string;
  providerSessionGeneration: string;
  flexCleanupCohort?: IControllerFlexCleanupEntry[];
  startedAt: Date;
  dispatchStartedAt?: Date;
}

export interface IControllerManagedSessionDocument {
  /** Optional only while migrating the shipped unqualified Codex identities. Never expires. */
  codexOrigin?: IControllerCodexOrigin;
  id: string;
  issuerId: string;
  projectIdentityId: string;
  harnessId: TControllerSessionId['harnessId'];
  runtimeId: TControllerSessionId;
  sessionIdentityId: string;
  providerSessionGeneration: string;
  sessionGenerationId?: string;
  sessionGenerationSequence?: number;
  state: TControllerManagedSessionState;
  managedAt: Date;
  admissionSource: TControllerManagedSessionAdmissionSource;
  updateId: string;
  deletion?: IControllerManagedSessionDeletion;
  retiredAt?: Date;
}

export type TControllerSessionCreationObligationState = 'pending' | 'admitted' | 'retired';

export interface IControllerSessionCreationObligationDocument {
  id: string;
  issuerId: string;
  projectIdentityId: string;
  runtimeId: TControllerSessionId;
  operationId: string;
  state: TControllerSessionCreationObligationState;
  requestedAt: Date;
  updateId: string;
  dispatchStartedAt?: Date;
  expectedFlexSessionGenerationId?: string;
  providerSessionGeneration?: string;
  sessionIdentityId?: string;
  terminalAt?: Date;
}

const isPlainObject = (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 hasExactKeys = (
  valueArg: Record<string, unknown>,
  requiredKeysArg: readonly string[],
  optionalKeysArg: readonly string[] = [],
): boolean => {
  const keys = Object.keys(valueArg);
  return requiredKeysArg.every((key) => Object.hasOwn(valueArg, key))
    && keys.every((key) => requiredKeysArg.includes(key) || optionalKeysArg.includes(key));
};

const isBase64UrlBytes = (valueArg: unknown, byteLengthArg: number): valueArg is string => (
  typeof valueArg === 'string'
  && base64UrlPattern.test(valueArg)
  && Buffer.from(valueArg, 'base64url').byteLength === byteLengthArg
  && Buffer.from(valueArg, 'base64url').toString('base64url') === valueArg
);

const isValidDate = (valueArg: unknown): valueArg is Date => (
  valueArg instanceof Date && Number.isFinite(valueArg.getTime()) && valueArg.getTime() >= 0
);

const isProviderGeneration = (valueArg: unknown): valueArg is string => (
  typeof valueArg === 'string'
  && valueArg.length > 0
  && Buffer.byteLength(valueArg, 'utf8') <= maximumProviderGenerationBytes
  && !/[\u0000-\u001f\u007f]/u.test(valueArg)
);

const isFlexSessionGenerationId = (valueArg: unknown): valueArg is string => (
  typeof valueArg === 'string'
  && valueArg.trim().length > 0
  && Buffer.byteLength(valueArg, 'utf8')
    <= plugins.flexharness.FLEX_SESSION_GENERATION_ID_MAX_BYTES
  && !/[\u0000-\u001f\u007f]/u.test(valueArg)
);

const isFlexSessionGenerationSequence = (valueArg: unknown): valueArg is number => (
  Number.isSafeInteger(valueArg) && Number(valueArg) >= 1
);

export const assertControllerFlexSessionGeneration: (
  sessionGenerationIdArg: unknown,
  sessionGenerationSequenceArg: unknown,
  providerSessionGenerationArg: unknown,
) => asserts sessionGenerationIdArg is string = (
  sessionGenerationIdArg,
  sessionGenerationSequenceArg,
  providerSessionGenerationArg,
) => {
  if (
    !isFlexSessionGenerationId(sessionGenerationIdArg)
    || !isFlexSessionGenerationSequence(sessionGenerationSequenceArg)
    || !isProviderGeneration(providerSessionGenerationArg)
    || providerSessionGenerationArg !== flexSessionProviderGeneration(
      sessionGenerationIdArg,
      sessionGenerationSequenceArg,
    )
  ) throw new Error('Invalid controller Flex session generation.');
};

export const assertControllerFlexSessionGenerationId: (
  valueArg: unknown,
) => asserts valueArg is string = (valueArg) => {
  if (!isFlexSessionGenerationId(valueArg)) {
    throw new Error('Invalid controller Flex session generation ID.');
  }
};

const isFlexCleanupSessionId = (valueArg: unknown): valueArg is string => (
  typeof valueArg === 'string'
  && valueArg.length > 0
  && Buffer.byteLength(valueArg, 'utf8') <= maximumNativeIdBytes
  && !/[\u0000-\u001f\u007f]/u.test(valueArg)
);

export const assertControllerFlexCleanupCohort: (
  valueArg: unknown,
) => asserts valueArg is IControllerFlexCleanupEntry[] = (valueArg) => {
  if (!Array.isArray(valueArg) || valueArg.length > controllerFlexCleanupCohortLimit) {
    throw new Error('Invalid controller Flex cleanup cohort.');
  }
  let previousSessionId: string | undefined;
  for (const entry of valueArg) {
    if (
      !isPlainObject(entry)
      || Reflect.ownKeys(entry).length !== 5
      || !hasExactKeys(entry, [
        'sessionId',
        'sessionGenerationId',
        'sessionGenerationSequence',
        'providerSessionGeneration',
        'cleanupRoot',
      ])
      || !isFlexCleanupSessionId(entry.sessionId)
      || typeof entry.cleanupRoot !== 'boolean'
      || (previousSessionId !== undefined && previousSessionId >= entry.sessionId)
    ) throw new Error('Invalid controller Flex cleanup cohort.');
    try {
      assertControllerFlexSessionGeneration(
        entry.sessionGenerationId,
        entry.sessionGenerationSequence,
        entry.providerSessionGeneration,
      );
    } catch {
      throw new Error('Invalid controller Flex cleanup cohort.');
    }
    previousSessionId = entry.sessionId;
  }
};

export const cloneControllerFlexCleanupCohort = (
  cohortArg: unknown,
): IControllerFlexCleanupEntry[] => {
  assertControllerFlexCleanupCohort(cohortArg);
  return cohortArg.map((entry) => ({
    sessionId: entry.sessionId,
    sessionGenerationId: entry.sessionGenerationId,
    sessionGenerationSequence: entry.sessionGenerationSequence,
    providerSessionGeneration: entry.providerSessionGeneration,
    cleanupRoot: entry.cleanupRoot,
  }));
};

export const controllerFlexCleanupCohortsEqual = (
  leftArg: readonly IControllerFlexCleanupEntry[],
  rightArg: readonly IControllerFlexCleanupEntry[],
): boolean => leftArg.length === rightArg.length
  && leftArg.every((entry, index) => (
    entry.sessionId === rightArg[index]?.sessionId
    && entry.sessionGenerationId === rightArg[index]?.sessionGenerationId
    && entry.sessionGenerationSequence === rightArg[index]?.sessionGenerationSequence
    && entry.providerSessionGeneration === rightArg[index]?.providerSessionGeneration
    && entry.cleanupRoot === rightArg[index]?.cleanupRoot
  ));

const isRuntimeId = (valueArg: unknown): valueArg is TControllerSessionId => (
  isPlainObject(valueArg)
  && hasExactKeys(valueArg, ['harnessId', 'nativeId'])
  && (valueArg.harnessId === 'opencode' || valueArg.harnessId === 'flex' || valueArg.harnessId === 'codex')
  && typeof valueArg.nativeId === 'string'
  && valueArg.nativeId.length > 0
  && Buffer.byteLength(valueArg.nativeId, 'utf8') <= maximumNativeIdBytes
);

const isManagedSessionDeletion = (
  valueArg: unknown,
): valueArg is IControllerManagedSessionDeletion => {
  if (
    !isPlainObject(valueArg)
    || !hasExactKeys(
      valueArg,
      [
        'operationId',
        'expectedBindingId',
        'supervisorGeneration',
        'providerSessionGeneration',
        'startedAt',
      ],
      ['flexCleanupCohort', 'dispatchStartedAt'],
    )
    || !isBase64UrlBytes(valueArg.operationId, 24)
    || !isBase64UrlBytes(valueArg.expectedBindingId, 32)
    || !isBase64UrlBytes(valueArg.supervisorGeneration, 32)
    || !isProviderGeneration(valueArg.providerSessionGeneration)
    || !isValidDate(valueArg.startedAt)
  ) return false;

  const hasFlexCleanupCohort = Object.hasOwn(valueArg, 'flexCleanupCohort');
  const hasDispatchStartedAt = Object.hasOwn(valueArg, 'dispatchStartedAt');
  if (hasFlexCleanupCohort) {
    try {
      assertControllerFlexCleanupCohort(valueArg.flexCleanupCohort);
    } catch {
      return false;
    }
  }
  return !hasDispatchStartedAt || (
    isValidDate(valueArg.dispatchStartedAt)
    && valueArg.dispatchStartedAt.getTime() >= valueArg.startedAt.getTime()
  );
};

const digest = (valueArg: unknown): string => plugins.crypto
  .createHash('sha256')
  .update(JSON.stringify(valueArg), 'utf8')
  .digest('base64url');

export const controllerManagedSessionDocumentId = (
  issuerIdArg: string,
  projectIdentityIdArg: string,
  harnessIdArg: TControllerSessionId['harnessId'],
  sessionIdentityIdArg: string,
): string => digest([
  'controller-managed-session-v1',
  issuerIdArg,
  projectIdentityIdArg,
  harnessIdArg,
  sessionIdentityIdArg,
]);

export const controllerSessionCreationObligationDocumentId = (
  issuerIdArg: string,
  projectIdentityIdArg: string,
  runtimeIdArg: TControllerSessionId,
): string => digest([
  'controller-session-creation-obligation-v1',
  issuerIdArg,
  projectIdentityIdArg,
  runtimeIdArg.harnessId,
  runtimeIdArg.nativeId,
]);

export const assertControllerManagedSessionDocument = (
  valueArg: unknown,
): asserts valueArg is IControllerManagedSessionDocument => {
  if (
    !isPlainObject(valueArg)
    || !hasExactKeys(
      valueArg,
      [
        'id',
        'issuerId',
        'projectIdentityId',
        'harnessId',
        'runtimeId',
        'sessionIdentityId',
        'providerSessionGeneration',
        'state',
        'managedAt',
        'admissionSource',
        'updateId',
      ],
      ['sessionGenerationId', 'sessionGenerationSequence', 'deletion', 'retiredAt', 'codexOrigin'],
    )
    || !isBase64UrlBytes(valueArg.issuerId, 32)
    || !isBase64UrlBytes(valueArg.projectIdentityId, 16)
    || (valueArg.harnessId !== 'opencode' && valueArg.harnessId !== 'flex' && valueArg.harnessId !== 'codex')
    || !isRuntimeId(valueArg.runtimeId)
    || valueArg.runtimeId.harnessId !== valueArg.harnessId
    || !isBase64UrlBytes(valueArg.sessionIdentityId, 32)
    || !isProviderGeneration(valueArg.providerSessionGeneration)
    || valueArg.id !== controllerManagedSessionDocumentId(
      valueArg.issuerId,
      valueArg.projectIdentityId,
      valueArg.harnessId,
      valueArg.sessionIdentityId,
    )
    || !['active', 'deleting', 'retired'].includes(String(valueArg.state))
    || !isValidDate(valueArg.managedAt)
    || (
      valueArg.admissionSource !== 'controller-created'
      && valueArg.admissionSource !== 'explicit-enrollment'
      && valueArg.admissionSource !== 'project-folder-discovery'
      && valueArg.admissionSource !== 'legacy-state-migration'
    )
    || !isBase64UrlBytes(valueArg.updateId, 32)
  ) throw new Error('Invalid controller managed session document.');

  if (Object.hasOwn(valueArg, 'codexOrigin')) {
    assertCodexOrigin(valueArg.codexOrigin);
    const qualified = codexQualifiedIdentity(valueArg.runtimeId.nativeId);
    if (valueArg.harnessId !== 'codex' || (qualified
      ? qualified.profileId !== valueArg.codexOrigin.profileId || qualified.rawThreadId !== valueArg.codexOrigin.rawThreadId
      : valueArg.runtimeId.nativeId !== valueArg.codexOrigin.rawThreadId)) throw new Error('Codex membership origin does not match its conversation identity.');
  } else if (codexQualifiedIdentity(valueArg.runtimeId.nativeId)) throw new Error('A qualified Codex conversation requires its durable origin.');

  const hasDeletion = Object.hasOwn(valueArg, 'deletion');
  const hasRetiredAt = Object.hasOwn(valueArg, 'retiredAt');
  const hasSessionGenerationId = Object.hasOwn(valueArg, 'sessionGenerationId');
  const hasSessionGenerationSequence = Object.hasOwn(valueArg, 'sessionGenerationSequence');
  if (valueArg.harnessId === 'flex') {
    try {
      assertControllerFlexSessionGeneration(
        valueArg.sessionGenerationId,
        valueArg.sessionGenerationSequence,
        valueArg.providerSessionGeneration,
      );
    } catch {
      throw new Error('Invalid controller managed Flex session generation.');
    }
  } else if (hasSessionGenerationId || hasSessionGenerationSequence) {
    throw new Error('Invalid controller managed OpenCode session generation.');
  }
  if (hasDeletion && !isManagedSessionDeletion(valueArg.deletion)) {
    throw new Error('Invalid controller managed session deletion.');
  }
  if (hasRetiredAt && !isValidDate(valueArg.retiredAt)) {
    throw new Error('Invalid controller managed session retirement.');
  }

  if (hasDeletion) {
    const deletion = valueArg.deletion as IControllerManagedSessionDeletion;
    if (deletion.providerSessionGeneration !== valueArg.providerSessionGeneration) {
      throw new Error('Invalid controller managed session deletion generation.');
    }
    if (valueArg.harnessId === 'flex') {
      const cohort = deletion.flexCleanupCohort;
      const roots = cohort?.filter((entry) => entry.cleanupRoot) ?? [];
      if (
        !cohort
        || cohort.length === 0
        || roots.length !== 1
        || roots[0].sessionId !== valueArg.runtimeId.nativeId
        || roots[0].sessionGenerationId !== valueArg.sessionGenerationId
        || roots[0].sessionGenerationSequence !== valueArg.sessionGenerationSequence
        || roots[0].providerSessionGeneration !== valueArg.providerSessionGeneration
      ) throw new Error('Invalid controller managed Flex session deletion root.');
    } else if (deletion.flexCleanupCohort !== undefined) {
      throw new Error('Invalid controller managed OpenCode session deletion cohort.');
    }
  }

  if (
    (valueArg.state === 'active' && (hasDeletion || hasRetiredAt))
    || (valueArg.state === 'deleting' && (
      !hasDeletion
      || hasRetiredAt
      || (
        valueArg.harnessId === 'flex'
          ? (valueArg.deletion as IControllerManagedSessionDeletion).flexCleanupCohort === undefined
            || (valueArg.deletion as IControllerManagedSessionDeletion).flexCleanupCohort!.length === 0
          : (valueArg.deletion as IControllerManagedSessionDeletion).flexCleanupCohort !== undefined
      )
      || (valueArg.deletion as IControllerManagedSessionDeletion).startedAt.getTime()
        < valueArg.managedAt.getTime()
    ))
    || (valueArg.state === 'retired' && (
      hasDeletion
      || !hasRetiredAt
      || (valueArg.retiredAt as Date).getTime() < valueArg.managedAt.getTime()
    ))
  ) throw new Error('Invalid controller managed session state.');
};

export const assertControllerSessionCreationObligationDocument = (
  valueArg: unknown,
): asserts valueArg is IControllerSessionCreationObligationDocument => {
  if (
    !isPlainObject(valueArg)
    || !hasExactKeys(
      valueArg,
      [
        'id',
        'issuerId',
        'projectIdentityId',
        'runtimeId',
        'operationId',
        'state',
        'requestedAt',
        'updateId',
      ],
      [
        'dispatchStartedAt',
        'expectedFlexSessionGenerationId',
        'providerSessionGeneration',
        'sessionIdentityId',
        'terminalAt',
      ],
    )
    || !isBase64UrlBytes(valueArg.issuerId, 32)
    || !isBase64UrlBytes(valueArg.projectIdentityId, 16)
    || !isRuntimeId(valueArg.runtimeId)
    || valueArg.runtimeId.harnessId === 'codex'
    || valueArg.id !== controllerSessionCreationObligationDocumentId(
      valueArg.issuerId,
      valueArg.projectIdentityId,
      valueArg.runtimeId,
    )
    || !isBase64UrlBytes(valueArg.operationId, 24)
    || !['pending', 'admitted', 'retired'].includes(String(valueArg.state))
    || !isValidDate(valueArg.requestedAt)
    || !isBase64UrlBytes(valueArg.updateId, 32)
  ) throw new Error('Invalid controller session creation obligation document.');

  const hasDispatchStartedAt = Object.hasOwn(valueArg, 'dispatchStartedAt');
  const hasExpectedFlexSessionGenerationId = Object.hasOwn(
    valueArg,
    'expectedFlexSessionGenerationId',
  );
  const hasProviderGeneration = Object.hasOwn(valueArg, 'providerSessionGeneration');
  const hasSessionIdentityId = Object.hasOwn(valueArg, 'sessionIdentityId');
  const hasTerminalAt = Object.hasOwn(valueArg, 'terminalAt');
  if (
    (hasDispatchStartedAt && (
      !isValidDate(valueArg.dispatchStartedAt)
      || valueArg.dispatchStartedAt.getTime() < valueArg.requestedAt.getTime()
    ))
    || (hasExpectedFlexSessionGenerationId && (() => {
      try {
        assertControllerFlexSessionGenerationId(valueArg.expectedFlexSessionGenerationId);
        return false;
      } catch {
        return true;
      }
    })())
    || (hasProviderGeneration && !isProviderGeneration(valueArg.providerSessionGeneration))
    || (hasSessionIdentityId && !isBase64UrlBytes(valueArg.sessionIdentityId, 32))
    || (hasTerminalAt && (
      !isValidDate(valueArg.terminalAt)
      || valueArg.terminalAt.getTime() < valueArg.requestedAt.getTime()
      || (
        hasDispatchStartedAt
        && valueArg.terminalAt.getTime() < (valueArg.dispatchStartedAt as Date).getTime()
      )
    ))
  ) throw new Error('Invalid controller session creation obligation facts.');

  if (
    (valueArg.state === 'pending' && (
      hasProviderGeneration
      || hasSessionIdentityId
      || hasTerminalAt
      || (
        valueArg.runtimeId.harnessId === 'flex'
          ? !hasExpectedFlexSessionGenerationId
          : hasExpectedFlexSessionGenerationId
      )
    ))
    || (valueArg.state === 'admitted' && (
      !hasDispatchStartedAt
      || !hasProviderGeneration
      || !hasSessionIdentityId
      || !hasTerminalAt
      || hasExpectedFlexSessionGenerationId
    ))
    || (valueArg.state === 'retired' && (
      hasProviderGeneration
      || hasSessionIdentityId
      || !hasTerminalAt
      || hasExpectedFlexSessionGenerationId
    ))
  ) throw new Error('Invalid controller session creation obligation state.');
};

@plugins.smartdata.compoundIndex({
  name: 'controller_managed_session_scope_state',
  key: {
    issuerId: 1,
    projectIdentityId: 1,
    harnessId: 1,
    state: 1,
    id: 1,
  },
})
@plugins.smartdata.compoundIndex({
  name: 'controller_managed_session_runtime',
  key: {
    issuerId: 1,
    projectIdentityId: 1,
    harnessId: 1,
    'runtimeId.harnessId': 1,
    'runtimeId.nativeId': 1,
    id: 1,
  },
})
@plugins.smartdata.managed({ collectionName: 'agl_controller_managed_sessions' })
@plugins.smartdata.exactPersistence({
  assertDocument: assertControllerManagedSessionDocument,
})
export class ControllerManagedSessionModel
  extends plugins.smartdata.SmartDataDbDoc<
    ControllerManagedSessionModel,
    IControllerManagedSessionDocument
  > {
  declare static exact: plugins.smartdata.TExact<ControllerManagedSessionModel>;
  @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 harnessId!: TControllerSessionId['harnessId'];

  @plugins.smartdata.svDb()
  public runtimeId!: TControllerSessionId;

  @plugins.smartdata.svDb()
  public sessionIdentityId!: string;

  @plugins.smartdata.svDb()
  public providerSessionGeneration!: string;

  @plugins.smartdata.svDb()
  public sessionGenerationId?: string;

  @plugins.smartdata.svDb()
  public sessionGenerationSequence?: number;

  @plugins.smartdata.svDb()
  public state!: TControllerManagedSessionState;

  @plugins.smartdata.svDb()
  public managedAt!: Date;

  @plugins.smartdata.svDb()
  public admissionSource!: TControllerManagedSessionAdmissionSource;

  @plugins.smartdata.svDb()
  public updateId!: string;

  @plugins.smartdata.svDb()
  public deletion?: IControllerManagedSessionDeletion;

  @plugins.smartdata.svDb()
  public retiredAt?: Date;
}

@plugins.smartdata.compoundIndex({
  name: 'controller_session_creation_obligation_scope_state',
  key: {
    issuerId: 1,
    projectIdentityId: 1,
    'runtimeId.harnessId': 1,
    state: 1,
    id: 1,
  },
})
@plugins.smartdata.managed({ collectionName: 'agl_controller_session_creation_obligations' })
@plugins.smartdata.exactPersistence({
  assertDocument: assertControllerSessionCreationObligationDocument,
})
export class ControllerSessionCreationObligationModel
  extends plugins.smartdata.SmartDataDbDoc<
    ControllerSessionCreationObligationModel,
    IControllerSessionCreationObligationDocument
  > {
  declare static exact: plugins.smartdata.TExact<ControllerSessionCreationObligationModel>;

  @plugins.smartdata.unI()
  public id!: string;

  @plugins.smartdata.svDb()
  public issuerId!: string;

  @plugins.smartdata.svDb()
  public projectIdentityId!: string;

  @plugins.smartdata.svDb()
  public runtimeId!: TControllerSessionId;

  @plugins.smartdata.svDb()
  public operationId!: string;

  @plugins.smartdata.svDb()
  public state!: TControllerSessionCreationObligationState;

  @plugins.smartdata.svDb()
  public requestedAt!: Date;

  @plugins.smartdata.svDb()
  public updateId!: string;

  @plugins.smartdata.svDb()
  public dispatchStartedAt?: Date;

  @plugins.smartdata.svDb()
  public expectedFlexSessionGenerationId?: string;

  @plugins.smartdata.svDb()
  public providerSessionGeneration?: string;

  @plugins.smartdata.svDb()
  public sessionIdentityId?: string;

  @plugins.smartdata.index({ expireAfterSeconds: 30 * 24 * 60 * 60 })
  public terminalAt?: Date;
}