// Wildduck Handler Type Definitions
// Internal handler interfaces and service classes

import { ObjectId } from 'mongodb';
import { Readable } from 'stream';
import { Wildduck } from './database';

export namespace Wildduck {
    // ============================================================================
    // Message Handler Types
    // ============================================================================

    /**
     * Message handler for email storage and retrieval operations
     */
    export interface WildduckMessageHandler {
        /**
         * Add a new message to a mailbox
         */
        add(options: WildduckMessageAddOptions, callback: WildduckMessageAddCallback): void;

        /**
         * Get message by ID
         */
        get(messageId: ObjectId, options: WildduckMessageGetOptions, callback: WildduckMessageGetCallback): void;

        /**
         * Delete a message
         */
        del(user: ObjectId, mailbox: ObjectId, message: ObjectId, callback: WildduckMessageDelCallback): void;

        /**
         * Move messages to another mailbox
         */
        move(options: WildduckMessageMoveOptions, callback: WildduckMessageMoveCallback): void;

        /**
         * Update message flags
         */
        update(user: ObjectId, mailbox: ObjectId, message: ObjectId, updates: any, callback: WildduckCallback): void;

        /**
         * Encrypt message using user's public key
         */
        encryptMessage(pubKey: string, raw: Buffer, callback: WildduckEncryptCallback): void;

        /**
         * Prepare message for storage (parse MIME, extract attachments)
         */
        prepareMessage(options: WildduckPrepareMessageOptions, callback: WildduckPrepareMessageCallback): void;

        /**
         * Attachment storage interface
         */
        attachmentStorage: WildduckAttachmentStorage;

        /**
         * Indexer for full-text search
         */
        indexer: WildduckIndexer;

        /**
         * Database connection
         */
        database: any;
    }

    export interface WildduckMessageAddOptions {
        user: ObjectId;
        mailbox: ObjectId;
        size: number;
        flags?: string[];
        date?: Date;
        raw?: Buffer | Readable;
        mimeTree?: any;
        envelope?: any;
        bodystructure?: string;
        meta?: {
            source?: string;
            from?: string;
            to?: string[];
            origin?: string;
            transtype?: string;
            time?: Date;
        };
    }

    export interface WildduckMessageGetOptions {
        fields?: Record<string, boolean>;
    }

    export interface WildduckMessageMoveOptions {
        user: ObjectId;
        source: {
            user: ObjectId;
            mailbox: ObjectId;
        };
        destination: {
            user: ObjectId;
            mailbox: ObjectId;
        };
        updates?: any;
        skipAttachments?: boolean;
    }

    export interface WildduckMessageInfo {
        id: ObjectId;
        uid: number;
        size: number;
        mailbox: ObjectId;
        user: ObjectId;
        status?: string;
    }

    export interface WildduckPrepareMessageOptions {
        raw: Buffer | Readable;
    }

    export interface WildduckPreparedMessage {
        mimeTree: any;
        size: number;
        bodystructure: string;
        envelope: any;
        headers: Record<string, string | string[]>;
    }

    export type WildduckMessageAddCallback = (err: Error | null, info?: WildduckMessageInfo) => void;
    export type WildduckMessageGetCallback = (err: Error | null, message?: any) => void;
    export type WildduckMessageDelCallback = (err: Error | null, deleted?: boolean) => void;
    export type WildduckMessageMoveCallback = (err: Error | null, result?: { message: ObjectId; mailbox: ObjectId }) => void;
    export type WildduckEncryptCallback = (err: Error | null, encrypted?: Buffer) => void;
    export type WildduckPrepareMessageCallback = (err: Error | null, prepared?: WildduckPreparedMessage) => void;

    // ============================================================================
    // User Handler Types
    // ============================================================================

    /**
     * User handler for user account management
     */
    export interface WildduckUserHandler {
        /**
         * Create a new user account
         */
        create(options: WildduckUserCreateOptions, callback: WildduckUserCreateCallback): void;

        /**
         * Get user data by ID or username
         */
        get(user: string | ObjectId, options: WildduckUserGetOptions, callback: WildduckUserGetCallback): void;

        /**
         * Update user account
         */
        update(user: ObjectId, updates: any, callback: WildduckCallback): void;

        /**
         * Delete user account
         */
        delete(user: ObjectId, callback: WildduckCallback): void;

        /**
         * Authenticate user credentials
         */
        authenticate(
            username: string,
            password: string,
            requiredScope: string,
            meta: WildduckAuthMeta,
            callback: WildduckAuthCallback
        ): void;

        /**
         * Reset user password
         */
        reset(user: ObjectId, options: WildduckPasswordResetOptions, callback: WildduckCallback): void;

        /**
         * User cache for quick lookups
         */
        userCache: WildduckUserCache;

        /**
         * Database connection
         */
        database: any;
    }

    export interface WildduckUserCreateOptions {
        username: string;
        password: string;
        address?: string;
        name?: string;
        quota?: number;
        retention?: number;
        enabled2fa?: string[];
        disabledScopes?: string[];
        tags?: string[];
        encryptMessages?: boolean;
        encryptForwarded?: boolean;
        pubKey?: string;
        metaData?: Record<string, any>;
        internalData?: Record<string, any>;
    }

    export interface WildduckUserGetOptions {
        fields?: Record<string, boolean>;
    }

    export interface WildduckPasswordResetOptions {
        password: string;
        hashedPassword?: boolean;
    }

    export interface WildduckAuthMeta {
        protocol: string;
        ip: string;
        sess?: string;
    }

    export interface WildduckAuthData {
        user: ObjectId;
        username: string;
        scope: string;
        require2fa?: string[];
        requirePasswordChange?: boolean;
    }

    export type WildduckUserCreateCallback = (err: Error | null, userId?: string) => void;
    export type WildduckUserGetCallback = (err: Error | null, userData?: any) => void;
    export type WildduckAuthCallback = (err: Error | null, authData?: WildduckAuthData) => void;

    // ============================================================================
    // Mailbox Handler Types
    // ============================================================================

    /**
     * Mailbox handler for mailbox operations
     */
    export interface WildduckMailboxHandler {
        /**
         * Create a new mailbox
         */
        create(user: ObjectId, path: string, opts: any, callback: WildduckMailboxCreateCallback): void;

        /**
         * Rename a mailbox
         */
        rename(user: ObjectId, mailbox: ObjectId, newPath: string, opts: any, callback: WildduckMailboxRenameCallback): void;

        /**
         * Delete a mailbox
         */
        del(user: ObjectId, mailbox: ObjectId, callback: WildduckMailboxDelCallback): void;

        /**
         * Update mailbox properties
         */
        update(user: ObjectId, mailbox: ObjectId, updates: any, callback: WildduckCallback): void;

        /**
         * Get mailbox by ID or path
         */
        get(user: ObjectId, mailbox: string | ObjectId, callback: WildduckMailboxGetCallback): void;

        /**
         * Database connection
         */
        database: any;
    }

    export type WildduckMailboxCreateCallback = (
        err: Error | null,
        status?: boolean | string,
        mailboxId?: ObjectId
    ) => void;
    export type WildduckMailboxRenameCallback = (err: Error | null, status?: boolean | string) => void;
    export type WildduckMailboxDelCallback = (err: Error | null, status?: boolean | string) => void;
    export type WildduckMailboxGetCallback = (err: Error | null, mailbox?: any) => void;

    // ============================================================================
    // Attachment Storage Types
    // ============================================================================

    /**
     * Attachment storage interface (GridFS)
     */
    export interface WildduckAttachmentStorage {
        /**
         * Get attachment by ID
         */
        get(attachmentId: string, callback: WildduckAttachmentGetCallback): void;

        /**
         * Create new attachment
         */
        create(attachmentStream: Readable, callback: WildduckAttachmentCreateCallback): void;

        /**
         * Create attachment from buffer
         */
        createReadable(chunks: Buffer[], callback: WildduckAttachmentCreateCallback): void;

        /**
         * Delete multiple attachments (deprecated)
         */
        deleteMany(attachmentIds: string[], magic: number, callback: WildduckCallback): void;

        /**
         * Delete multiple attachments (async)
         */
        deleteManyAsync(attachmentIds: string[], magic: number): Promise<void>;

        /**
         * Update attachment reference count
         */
        updateMany(attachmentIds: string[], count: number, magic: number): Promise<void>;

        /**
         * GridFS bucket
         */
        gridfs: any;
    }

    export interface WildduckAttachmentData {
        contentType: string;
        transferEncoding: string;
        metadata: {
            magic: number;
            [key: string]: any;
        };
        createReadStream(): Readable;
    }

    export type WildduckAttachmentGetCallback = (err: Error | null, attachmentData?: WildduckAttachmentData) => void;
    export type WildduckAttachmentCreateCallback = (err: Error | null, hash?: string) => void;

    // ============================================================================
    // Indexer Types
    // ============================================================================

    /**
     * Indexer for full-text search and message processing
     */
    export interface WildduckIndexer {
        /**
         * Extract searchable data from MIME tree
         */
        getMaildata(mimeTree: any): any;

        /**
         * Rebuild message from MIME tree
         */
        rebuild(mimeTree: any): { type: 'stream'; value: Readable } | { type: 'buffer'; value: Buffer };

        /**
         * Store message body parts for indexing
         */
        storeNodeBodies(maildata: any, mimeTree: any, callback: WildduckCallback): void;
    }

    // ============================================================================
    // User Cache Types
    // ============================================================================

    /**
     * User cache interface (Redis)
     */
    export interface WildduckUserCache {
        /**
         * Get value from cache
         */
        get(key: string, callback: WildduckCacheGetCallback): void;

        /**
         * Set value in cache with TTL
         */
        set(key: string, value: any, ttl: number, callback: WildduckCallback): void;

        /**
         * Remove value from cache
         */
        remove(key: string, callback: WildduckCallback): void;

        /**
         * Flush all cache entries
         */
        flush(callback: WildduckCallback): void;
    }

    export type WildduckCacheGetCallback = (err: Error | null, value?: any) => void;

    // ============================================================================
    // Task Handler Types
    // ============================================================================

    /**
     * Task handler for background job processing
     */
    export interface WildduckTaskHandler {
        /**
         * Enqueue a new task
         */
        add(type: string, data: any, callback: WildduckTaskCallback): void;

        /**
         * Process pending tasks
         */
        process(type: string, handler: WildduckTaskProcessor): void;

        /**
         * Database connection
         */
        database: any;
    }

    export type WildduckTaskCallback = (err: Error | null, taskId?: ObjectId) => void;
    export type WildduckTaskProcessor = (task: any, callback: WildduckCallback) => void;

    // ============================================================================
    // Settings Handler Types
    // ============================================================================

    /**
     * Settings handler for system configuration
     */
    export interface WildduckSettingsHandler {
        /**
         * Get setting value by key
         */
        get(key: string, callback: WildduckSettingGetCallback): void;

        /**
         * Get multiple settings by keys
         */
        getMulti(keys: string[], callback: WildduckSettingsGetCallback): void;

        /**
         * Set setting value
         */
        set(key: string, value: any, callback: WildduckCallback): void;

        /**
         * Database connection
         */
        database: any;
    }

    export type WildduckSettingGetCallback = (err: Error | null, value?: any) => void;
    export type WildduckSettingsGetCallback = (err: Error | null, settings?: Record<string, any>) => void;

    // ============================================================================
    // IMAP Notifier Types
    // ============================================================================

    /**
     * IMAP notifier for real-time notifications
     */
    export interface WildduckIMAPNotifier {
        /**
         * Notify about new message
         */
        addEntries(user: ObjectId, path: string, entries: any[], callback: WildduckCallback): void;

        /**
         * Notify about message deletion
         */
        fire(user: ObjectId, path: string): void;

        /**
         * Get notification listener
         */
        getUpdates(user: ObjectId): any;
    }

    // ============================================================================
    // Common Callback Types
    // ============================================================================

    /**
     * Generic callback type
     */
    export type WildduckCallback = (err?: Error | null) => void;

    /**
     * Callback with boolean result
     */
    export type WildduckBooleanCallback = (err: Error | null, result?: boolean) => void;

    /**
     * Callback with count result
     */
    export type WildduckCountCallback = (err: Error | null, count?: number) => void;
}