import { STATUS_CODES } from 'node:http';
import { HttpStatus, Logger } from '@nestjs/common';
import { capitalize } from 'lodash-es';
const BaseTypeToHttpStatusMap = {
    too_many_requests: HttpStatus.TOO_MANY_REQUESTS,
    bad_request: HttpStatus.BAD_REQUEST,
    resource_not_found: HttpStatus.NOT_FOUND,
    resource_already_exists: HttpStatus.BAD_REQUEST,
    invalid_input: HttpStatus.BAD_REQUEST,
    action_forbidden: HttpStatus.FORBIDDEN,
    no_permission: HttpStatus.FORBIDDEN,
    quota_exceeded: HttpStatus.PAYMENT_REQUIRED,
    authentication_required: HttpStatus.UNAUTHORIZED,
    internal_server_error: HttpStatus.INTERNAL_SERVER_ERROR,
};
export class UserFriendlyError extends Error {
    constructor(type, name, message, args) {
        const defaultMsg = USER_FRIENDLY_ERRORS[name].message;
        // disallow message override for `internal_server_error`
        // to avoid leak internal information to user
        let msg = name === 'internal_server_error' ? defaultMsg : (message ?? defaultMsg);
        if (typeof msg === 'function') {
            msg = msg(args);
        }
        super(msg);
        this.status = BaseTypeToHttpStatusMap[type];
        this.type = type;
        this.name = name;
        this.data = args;
    }
    toJSON() {
        return {
            status: this.status,
            code: STATUS_CODES[this.status] ?? 'BAD REQUEST',
            type: this.type.toUpperCase(),
            name: this.name.toUpperCase(),
            message: this.message,
            data: this.data,
        };
    }
    log(context) {
        // ignore all user behavior error log
        if (this.type !== 'internal_server_error') {
            return;
        }
        new Logger(context).error('Internal server error', this.cause ? (this.cause.stack ?? this.cause) : this.stack);
    }
}
/**
 *
 * @ObjectType()
 * export class XXXDataType {
 *   @Field()
 *
 * }
 */
function generateErrorArgs(name, args) {
    const typeName = `${name}DataType`;
    const lines = [`@ObjectType()`, `class ${typeName} {`];
    Object.entries(args).forEach(([arg, fieldArgs]) => {
        if (typeof fieldArgs === 'object') {
            const subResult = generateErrorArgs(name + 'Field' + capitalize(arg), fieldArgs);
            lines.unshift(subResult.def);
            lines.push(`  @Field(() => ${subResult.name}) ${arg}!: ${subResult.name};`);
        }
        else {
            lines.push(`  @Field() ${arg}!: ${fieldArgs}`);
        }
    });
    lines.push('}');
    return { name: typeName, def: lines.join('\n') };
}
export function generateUserFriendlyErrors() {
    const output = [
        '/* eslint-disable */',
        '// AUTO GENERATED FILE',
        `import { createUnionType, Field, ObjectType, registerEnumType } from '@nestjs/graphql';`,
        '',
        `import { UserFriendlyError } from './def';`,
    ];
    const errorNames = [];
    const argTypes = [];
    for (const code in USER_FRIENDLY_ERRORS) {
        errorNames.push(code.toUpperCase());
        // @ts-expect-error allow
        const options = USER_FRIENDLY_ERRORS[code];
        const className = code
            .split('_')
            .map(part => part.charAt(0).toUpperCase() + part.slice(1))
            .join('');
        const args = options.args
            ? generateErrorArgs(className, options.args)
            : null;
        const classDef = `
export class ${className} extends UserFriendlyError {
  constructor(${args ? `args: ${args.name}, ` : ''}message?: string${args ? ` | ((args: ${args.name}) => string)` : ''}) {
    super('${options.type}', '${code}', message${args ? ', args' : ''});
  }
}`;
        if (args) {
            output.push(args.def);
            argTypes.push(args.name);
        }
        output.push(classDef);
    }
    output.push(`export enum ErrorNames {
  ${errorNames.join(',\n  ')}
}
registerEnumType(ErrorNames, {
  name: 'ErrorNames'
})

export const ErrorDataUnionType = createUnionType({
  name: 'ErrorDataUnion',
  types: () =>
    [${argTypes.join(', ')}] as const,
});
`);
    return output.join('\n');
}
// DEFINE ALL USER FRIENDLY ERRORS HERE
export const USER_FRIENDLY_ERRORS = {
    // Internal uncaught errors
    internal_server_error: {
        type: 'internal_server_error',
        message: 'An internal error occurred.',
    },
    too_many_request: {
        type: 'too_many_requests',
        message: 'Too many requests.',
    },
    // User Errors
    user_not_found: {
        type: 'resource_not_found',
        message: 'User not found.',
    },
    user_avatar_not_found: {
        type: 'resource_not_found',
        message: 'User avatar not found.',
    },
    email_already_used: {
        type: 'resource_already_exists',
        message: 'This email has already been registered.',
    },
    same_email_provided: {
        type: 'invalid_input',
        message: 'You are trying to update your account email to the same as the old one.',
    },
    wrong_sign_in_credentials: {
        type: 'invalid_input',
        message: 'Wrong user email or password.',
    },
    unknown_oauth_provider: {
        type: 'invalid_input',
        args: { name: 'string' },
        message: ({ name }) => `Unknown authentication provider ${name}.`,
    },
    oauth_state_expired: {
        type: 'bad_request',
        message: 'OAuth state expired, please try again.',
    },
    invalid_oauth_callback_state: {
        type: 'bad_request',
        message: 'Invalid callback state parameter.',
    },
    missing_oauth_query_parameter: {
        type: 'bad_request',
        args: { name: 'string' },
        message: ({ name }) => `Missing query parameter \`${name}\`.`,
    },
    oauth_account_already_connected: {
        type: 'bad_request',
        message: 'The third-party account has already been connected to another user.',
    },
    invalid_email: {
        type: 'invalid_input',
        message: 'An invalid email provided.',
    },
    invalid_password_length: {
        type: 'invalid_input',
        args: { min: 'number', max: 'number' },
        message: ({ min, max }) => `Password must be between ${min} and ${max} characters`,
    },
    password_required: {
        type: 'invalid_input',
        message: 'Password is required.',
    },
    wrong_sign_in_method: {
        type: 'invalid_input',
        message: 'You are trying to sign in by a different method than you signed up with.',
    },
    early_access_required: {
        type: 'action_forbidden',
        message: `You don't have early access permission. Visit https://community.affine.pro/c/insider-general/ for more information.`,
    },
    sign_up_forbidden: {
        type: 'action_forbidden',
        message: `You are not allowed to sign up.`,
    },
    email_token_not_found: {
        type: 'invalid_input',
        message: 'The email token provided is not found.',
    },
    invalid_email_token: {
        type: 'invalid_input',
        message: 'An invalid email token provided.',
    },
    link_expired: {
        type: 'bad_request',
        message: 'The link has expired.',
    },
    // Authentication & Permission Errors
    authentication_required: {
        type: 'authentication_required',
        message: 'You must sign in first to access this resource.',
    },
    action_forbidden: {
        type: 'action_forbidden',
        message: 'You are not allowed to perform this action.',
    },
    access_denied: {
        type: 'no_permission',
        message: 'You do not have permission to access this resource.',
    },
    email_verification_required: {
        type: 'action_forbidden',
        message: 'You must verify your email before accessing this resource.',
    },
    // Workspace & Doc & Sync errors
    workspace_not_found: {
        type: 'resource_not_found',
        args: { workspaceId: 'string' },
        message: ({ workspaceId }) => `Workspace ${workspaceId} not found.`,
    },
    not_in_workspace: {
        type: 'action_forbidden',
        args: { workspaceId: 'string' },
        message: ({ workspaceId }) => `You should join in workspace ${workspaceId} before broadcasting messages.`,
    },
    workspace_access_denied: {
        type: 'no_permission',
        args: { workspaceId: 'string' },
        message: ({ workspaceId }) => `You do not have permission to access workspace ${workspaceId}.`,
    },
    workspace_owner_not_found: {
        type: 'internal_server_error',
        args: { workspaceId: 'string' },
        message: ({ workspaceId }) => `Owner of workspace ${workspaceId} not found.`,
    },
    cant_change_workspace_owner: {
        type: 'action_forbidden',
        message: 'You are not allowed to change the owner of a workspace.',
    },
    doc_not_found: {
        type: 'resource_not_found',
        args: { workspaceId: 'string', docId: 'string' },
        message: ({ workspaceId, docId }) => `Doc ${docId} under workspace ${workspaceId} not found.`,
    },
    doc_access_denied: {
        type: 'no_permission',
        args: { workspaceId: 'string', docId: 'string' },
        message: ({ workspaceId, docId }) => `You do not have permission to access doc ${docId} under workspace ${workspaceId}.`,
    },
    version_rejected: {
        type: 'action_forbidden',
        args: { version: 'string', serverVersion: 'string' },
        message: ({ version, serverVersion }) => `Your client with version ${version} is rejected by remote sync server. Please upgrade to ${serverVersion}.`,
    },
    invalid_history_timestamp: {
        type: 'invalid_input',
        args: { timestamp: 'string' },
        message: 'Invalid doc history timestamp provided.',
    },
    doc_history_not_found: {
        type: 'resource_not_found',
        args: { workspaceId: 'string', docId: 'string', timestamp: 'number' },
        message: ({ workspaceId, docId, timestamp }) => `History of ${docId} at ${timestamp} under workspace ${workspaceId}.`,
    },
    blob_not_found: {
        type: 'resource_not_found',
        args: { workspaceId: 'string', blobId: 'string' },
        message: ({ workspaceId, blobId }) => `Blob ${blobId} not found in workspace ${workspaceId}.`,
    },
    expect_to_publish_page: {
        type: 'invalid_input',
        message: 'Expected to publish a page, not a workspace.',
    },
    expect_to_revoke_public_page: {
        type: 'invalid_input',
        message: 'Expected to revoke a public page, not a workspace.',
    },
    page_is_not_public: {
        type: 'bad_request',
        message: 'Page is not public.',
    },
    // Subscription Errors
    failed_to_checkout: {
        type: 'internal_server_error',
        message: 'Failed to create checkout session.',
    },
    subscription_already_exists: {
        type: 'resource_already_exists',
        args: { plan: 'string' },
        message: ({ plan }) => `You have already subscribed to the ${plan} plan.`,
    },
    subscription_not_exists: {
        type: 'resource_not_found',
        args: { plan: 'string' },
        message: ({ plan }) => `You didn't subscribe to the ${plan} plan.`,
    },
    subscription_has_been_canceled: {
        type: 'action_forbidden',
        message: 'Your subscription has already been canceled.',
    },
    subscription_expired: {
        type: 'action_forbidden',
        message: 'Your subscription has expired.',
    },
    same_subscription_recurring: {
        type: 'bad_request',
        args: { recurring: 'string' },
        message: ({ recurring }) => `Your subscription has already been in ${recurring} recurring state.`,
    },
    customer_portal_create_failed: {
        type: 'internal_server_error',
        message: 'Failed to create customer portal session.',
    },
    subscription_plan_not_found: {
        type: 'resource_not_found',
        args: { plan: 'string', recurring: 'string' },
        message: 'You are trying to access a unknown subscription plan.',
    },
    cant_update_lifetime_subscription: {
        type: 'action_forbidden',
        message: 'You cannot update a lifetime subscription.',
    },
    // Copilot errors
    copilot_session_not_found: {
        type: 'resource_not_found',
        message: `Copilot session not found.`,
    },
    copilot_session_deleted: {
        type: 'action_forbidden',
        message: `Copilot session has been deleted.`,
    },
    no_copilot_provider_available: {
        type: 'internal_server_error',
        message: `No copilot provider available.`,
    },
    copilot_failed_to_generate_text: {
        type: 'internal_server_error',
        message: `Failed to generate text.`,
    },
    copilot_failed_to_create_message: {
        type: 'internal_server_error',
        message: `Failed to create chat message.`,
    },
    unsplash_is_not_configured: {
        type: 'internal_server_error',
        message: `Unsplash is not configured.`,
    },
    copilot_action_taken: {
        type: 'action_forbidden',
        message: `Action has been taken, no more messages allowed.`,
    },
    copilot_message_not_found: {
        type: 'resource_not_found',
        args: { messageId: 'string' },
        message: ({ messageId }) => `Copilot message ${messageId} not found.`,
    },
    copilot_prompt_not_found: {
        type: 'resource_not_found',
        args: { name: 'string' },
        message: ({ name }) => `Copilot prompt ${name} not found.`,
    },
    copilot_prompt_invalid: {
        type: 'invalid_input',
        message: `Copilot prompt is invalid.`,
    },
    copilot_provider_side_error: {
        type: 'internal_server_error',
        args: { provider: 'string', kind: 'string', message: 'string' },
        message: ({ provider, kind, message }) => `Provider ${provider} failed with ${kind} error: ${message || 'unknown'}`,
    },
    // Quota & Limit errors
    blob_quota_exceeded: {
        type: 'quota_exceeded',
        message: 'You have exceeded your blob storage quota.',
    },
    member_quota_exceeded: {
        type: 'quota_exceeded',
        message: 'You have exceeded your workspace member quota.',
    },
    copilot_quota_exceeded: {
        type: 'quota_exceeded',
        message: 'You have reached the limit of actions in this workspace, please upgrade your plan.',
    },
    // Config errors
    runtime_config_not_found: {
        type: 'resource_not_found',
        args: { key: 'string' },
        message: ({ key }) => `Runtime config ${key} not found.`,
    },
    invalid_runtime_config_type: {
        type: 'invalid_input',
        args: { key: 'string', want: 'string', get: 'string' },
        message: ({ key, want, get }) => `Invalid runtime config type  for '${key}', want '${want}', but get ${get}.`,
    },
    mailer_service_is_not_configured: {
        type: 'internal_server_error',
        message: 'Mailer service is not configured.',
    },
    cannot_delete_all_admin_account: {
        type: 'action_forbidden',
        message: 'Cannot delete all admin accounts.',
    },
    cannot_delete_own_account: {
        type: 'action_forbidden',
        message: 'Cannot delete own account.',
    },
};
//# sourceMappingURL=def.js.map