import type { APIPromise } from '../../../core/api-promise';
import type { PagePromise } from '../../../core/pagination';
import type { RequestOptions } from '../../../internal/request-options';
import type { RipplingSDK } from '../../../client';
import type * as Shared from '../../../resources/shared';
import type { GroupMembersPageCursorURL } from '../../../resources/shared';
import type {
  ExclusionMemberListParams,
  ExclusionMemberUpdateParams,
  ExclusionMemberUpdateResponse,
} from '../../../resources/supergroups/exclusion-members';
import type {
  InclusionMemberListParams,
  InclusionMemberUpdateParams,
  InclusionMemberUpdateResponse,
} from '../../../resources/supergroups/inclusion-members';
import type { MemberListParams } from '../../../resources/supergroups/members';
import type { SupergroupRetrieveResponse } from '../../../resources/supergroups/supergroups';
import { Group, type GroupProps } from '../group';

/** Authenticated supergroup resources supplied per call. */
export interface GroupOperationsContext {
  readonly supergroups: {
    readonly retrieve: RipplingSDK['supergroups']['retrieve'];
    readonly members: Pick<RipplingSDK['supergroups']['members'], 'list'>;
    readonly inclusionMembers: Pick<RipplingSDK['supergroups']['inclusionMembers'], 'list' | 'update'>;
    readonly exclusionMembers: Pick<RipplingSDK['supergroups']['exclusionMembers'], 'list' | 'update'>;
  };
}

export interface GroupMembers {
  list(
    ctx: GroupOperationsContext,
    params?: MemberListParams,
    options?: RequestOptions,
  ): PagePromise<GroupMembersPageCursorURL, Shared.GroupMember>;
}

export interface GroupInclusionMembers {
  list(
    ctx: GroupOperationsContext,
    params?: InclusionMemberListParams,
    options?: RequestOptions,
  ): PagePromise<GroupMembersPageCursorURL, Shared.GroupMember>;
  update(
    ctx: GroupOperationsContext,
    body: InclusionMemberUpdateParams,
    options?: RequestOptions,
  ): APIPromise<InclusionMemberUpdateResponse>;
}

export interface GroupExclusionMembers {
  list(
    ctx: GroupOperationsContext,
    params?: ExclusionMemberListParams,
    options?: RequestOptions,
  ): PagePromise<GroupMembersPageCursorURL, Shared.GroupMember>;
  update(
    ctx: GroupOperationsContext,
    body: ExclusionMemberUpdateParams,
    options?: RequestOptions,
  ): APIPromise<ExclusionMemberUpdateResponse>;
}

export interface GroupOperations {
  retrieve(ctx: GroupOperationsContext, options?: RequestOptions): APIPromise<SupergroupRetrieveResponse>;
  readonly members: GroupMembers;
  readonly inclusionMembers: GroupInclusionMembers;
  readonly exclusionMembers: GroupExclusionMembers;
}

export interface GroupReference extends GroupOperations {
  readonly id: string;
}

export interface GroupClient {
  retrieve(options?: RequestOptions): APIPromise<SupergroupRetrieveResponse>;
  readonly members: {
    list(
      params?: MemberListParams,
      options?: RequestOptions,
    ): PagePromise<GroupMembersPageCursorURL, Shared.GroupMember>;
  };
  readonly inclusionMembers: {
    list(
      params?: InclusionMemberListParams,
      options?: RequestOptions,
    ): PagePromise<GroupMembersPageCursorURL, Shared.GroupMember>;
    update(
      body: InclusionMemberUpdateParams,
      options?: RequestOptions,
    ): APIPromise<InclusionMemberUpdateResponse>;
  };
  readonly exclusionMembers: {
    list(
      params?: ExclusionMemberListParams,
      options?: RequestOptions,
    ): PagePromise<GroupMembersPageCursorURL, Shared.GroupMember>;
    update(
      body: ExclusionMemberUpdateParams,
      options?: RequestOptions,
    ): APIPromise<ExclusionMemberUpdateResponse>;
  };
}

/** Create an unregistered group configuration for reuse or embedding. */
export function defineGroup(props: GroupProps): DefinedGroup {
  return new DefinedGroup(props);
}

export class DefinedGroup extends Group {
  withId(groupId: string): GroupReference {
    return createGroupReference(groupId);
  }
}

/** @internal Creates a credential-free runtime reference to a deployed supergroup. */
export function createGroupReference(groupId: string): GroupReference {
  if (typeof groupId !== 'string' || !/^[a-f\d]{24}$/i.test(groupId)) {
    throw new TypeError('Supergroup ID must be a 24-character hexadecimal string.');
  }
  return {
    id: groupId,
    retrieve: (ctx, options) => ctx.supergroups.retrieve(groupId, options),
    members: {
      list: (ctx, params, options) => ctx.supergroups.members.list(groupId, params, options),
    },
    inclusionMembers: {
      list: (ctx, params, options) => ctx.supergroups.inclusionMembers.list(groupId, params, options),
      update: (ctx, body, options) => ctx.supergroups.inclusionMembers.update(groupId, body, options),
    },
    exclusionMembers: {
      list: (ctx, params, options) => ctx.supergroups.exclusionMembers.list(groupId, params, options),
      update: (ctx, body, options) => ctx.supergroups.exclusionMembers.update(groupId, body, options),
    },
  };
}

/** @internal Binds supergroup operations to an authenticated client context. */
export function createGroupClient(
  ctx: GroupOperationsContext,
  definition: GroupReference | string,
): GroupClient {
  const reference = typeof definition === 'string' ? createGroupReference(definition) : definition;
  return {
    retrieve: (options) => reference.retrieve(ctx, options),
    members: {
      list: (params, options) => reference.members.list(ctx, params, options),
    },
    inclusionMembers: {
      list: (params, options) => reference.inclusionMembers.list(ctx, params, options),
      update: (body, options) => reference.inclusionMembers.update(ctx, body, options),
    },
    exclusionMembers: {
      list: (params, options) => reference.exclusionMembers.list(ctx, params, options),
      update: (body, options) => reference.exclusionMembers.update(ctx, body, options),
    },
  };
}