import * as plugins from './plugins.js';
import type * as requests from './requests.js';
import type { IControllerProject, IControllerSession, TControllerSessionId } from './interfaces.js';

export const controllerMcpBrowserMaximumImageBytes = 512 * 1024;
export const controllerMcpBrowserOperationTimeoutMs = 20_000;
export type TControllerMcpBrowserActionResult =
  | Exclude<plugins.browserRuntime.TBrowserAgentActionResult, { action: 'screenshot' }>
  | { action: 'screenshot'; image: { mimeType: 'image/jpeg' | 'image/png'; data: string } };

export interface IReq_ControllerMcpBrowserAction extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpBrowserAction
> {
  method: 'agl.mcp.browser.action';
  /**
   * The subject is the calling chat, proven by its caller credential. A caller-supplied task id
   * would only restate what the credential already proves, and a terminal subject has no task id
   * to supply, so the request carries none.
   */
  request: {
    projectId: string;
    resourceId: string;
    expectedAttachmentRevision: number;
    action: plugins.browserRuntime.TBrowserAgentAction;
  };
  response: { result: TControllerMcpBrowserActionResult };
}

export interface IReq_ControllerMcpProjectCreate extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpProjectCreate
> {
  method: 'agl.mcp.project.create';
  request: requests.IReq_ControllerProjectCreate['request'];
  response: requests.IReq_ControllerProjectCreate['response'];
}

export interface IReq_ControllerMcpModelList extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpModelList
> {
  method: 'agl.mcp.model.list';
  request: requests.IReq_ControllerModelList['request'];
  response: requests.IReq_ControllerModelList['response'];
}

export interface IReq_ControllerMcpSessionCreate extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpSessionCreate
> {
  method: 'agl.mcp.session.create';
  request: requests.IReq_ControllerSessionCreate['request'];
  response: requests.IReq_ControllerSessionCreate['response'];
}

export interface IReq_ControllerMcpSessionModelUpdate extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpSessionModelUpdate
> {
  method: 'agl.mcp.session.model.update';
  request: requests.IReq_ControllerSessionModelUpdate['request'];
  response: requests.IReq_ControllerSessionModelUpdate['response'];
}

export interface IReq_ControllerMcpSessionRename extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpSessionRename
> {
  method: 'agl.mcp.session.rename';
  request: requests.IReq_ControllerSessionRename['request'];
  response: requests.IReq_ControllerSessionRename['response'];
}

export interface IReq_ControllerMcpSessionArchive extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpSessionArchive
> {
  method: 'agl.mcp.session.archive';
  request: requests.IReq_ControllerSessionArchive['request'];
  response: requests.IReq_ControllerSessionArchive['response'];
}

export interface IReq_ControllerMcpSessionAbort extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpSessionAbort
> {
  method: 'agl.mcp.session.abort';
  request: requests.IReq_ControllerSessionAbort['request'];
  response: requests.IReq_ControllerSessionAbort['response'];
}

export interface IReq_ControllerMcpResourceList extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpResourceList
> {
  method: 'agl.mcp.resource.list';
  request: requests.IReq_ControllerResourceList['request'];
  response: requests.IReq_ControllerResourceList['response'];
}

export interface IReq_ControllerMcpResourceCreate extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpResourceCreate
> {
  method: 'agl.mcp.resource.create';
  request: requests.IReq_ControllerResourceCreate['request'];
  response: requests.IReq_ControllerResourceCreate['response'];
}

export interface IReq_ControllerMcpResourceRename extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpResourceRename
> {
  method: 'agl.mcp.resource.rename';
  request: requests.IReq_ControllerResourceRename['request'];
  response: requests.IReq_ControllerResourceRename['response'];
}

export interface IReq_ControllerMcpResourceAttach extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpResourceAttach
> {
  method: 'agl.mcp.resource.attach';
  /**
   * Attaches to the caller's own subject. `sessionId` is accepted only from a shared harness
   * runtime, which has no single chat of its own and must therefore name which of its own tasks
   * to attach to; a task or terminal caller must omit it.
   */
  request: {
    projectId: string;
    resourceId: string;
    sessionId?: TControllerSessionId;
    expectedAttachmentRevision: number;
  };
  response: requests.IReq_ControllerResourceAttach['response'];
}

export interface IReq_ControllerMcpResourceDetach extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpResourceDetach
> {
  method: 'agl.mcp.resource.detach';
  /**
   * Removes the caller's own membership, never the whole set. `sessionId` is accepted only from a
   * shared harness runtime, which has no single chat of its own and must therefore name which of
   * its own tasks to release; a task or terminal caller must omit it.
   */
  request: {
    projectId: string;
    resourceId: string;
    sessionId?: TControllerSessionId;
    expectedAttachmentRevision: number;
  };
  response: requests.IReq_ControllerResourceDetach['response'];
}

export interface IReq_ControllerMcpResourceStart extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpResourceStart
> {
  method: 'agl.mcp.resource.start';
  request: requests.IReq_ControllerResourceStart['request'];
  response: requests.IReq_ControllerResourceStart['response'];
}

export interface IReq_ControllerMcpResourceStop extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpResourceStop
> {
  method: 'agl.mcp.resource.stop';
  request: requests.IReq_ControllerResourceStop['request'];
  response: requests.IReq_ControllerResourceStop['response'];
}

export interface IReq_ControllerMcpResourceRetire extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpResourceRetire
> {
  method: 'agl.mcp.resource.retire';
  request: requests.IReq_ControllerResourceRetire['request'];
  response: requests.IReq_ControllerResourceRetire['response'];
}

export interface IReq_ControllerMcpContextResolve extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest, IReq_ControllerMcpContextResolve
> {
  method: 'agl.mcp.context.resolve';
  request: { directory: string; sessionId?: TControllerSessionId };
  response: { project: IControllerProject; session?: IControllerSession };
}

export const controllerMcpWorkspaceMethods = [
  'agl.mcp.browser.action',
  'agl.mcp.project.create',
  'agl.mcp.model.list',
  'agl.mcp.session.create',
  'agl.mcp.session.model.update',
  'agl.mcp.session.rename',
  'agl.mcp.session.archive',
  'agl.mcp.session.abort',
  'agl.mcp.resource.list',
  'agl.mcp.resource.create',
  'agl.mcp.resource.rename',
  'agl.mcp.resource.attach',
  'agl.mcp.resource.detach',
  'agl.mcp.resource.start',
  'agl.mcp.resource.stop',
  'agl.mcp.resource.retire',
  'agl.mcp.context.resolve',
] as const;
export type TControllerMcpWorkspaceMethod = (typeof controllerMcpWorkspaceMethods)[number];
export type TControllerMcpWorkspaceTypedRequest =
  | IReq_ControllerMcpBrowserAction
  | IReq_ControllerMcpProjectCreate
  | IReq_ControllerMcpModelList
  | IReq_ControllerMcpSessionCreate
  | IReq_ControllerMcpSessionModelUpdate
  | IReq_ControllerMcpSessionRename
  | IReq_ControllerMcpSessionArchive
  | IReq_ControllerMcpSessionAbort
  | IReq_ControllerMcpResourceList
  | IReq_ControllerMcpResourceCreate
  | IReq_ControllerMcpResourceRename
  | IReq_ControllerMcpResourceAttach
  | IReq_ControllerMcpResourceDetach
  | IReq_ControllerMcpResourceStart
  | IReq_ControllerMcpResourceStop
  | IReq_ControllerMcpResourceRetire
  | IReq_ControllerMcpContextResolve;
export type TControllerMcpWorkspaceRequestMap = {
  [TRequest in TControllerMcpWorkspaceTypedRequest as TRequest['method']]: TRequest;
};
export type TControllerMcpWorkspaceRequest<TMethod extends TControllerMcpWorkspaceMethod> =
  TControllerMcpWorkspaceRequestMap[TMethod]['request'];
export type TControllerMcpWorkspaceResponse<TMethod extends TControllerMcpWorkspaceMethod> =
  TControllerMcpWorkspaceRequestMap[TMethod]['response'];