/**
 * 文件：publisher-manager.ts
 * 作用：发布平台管理器，统一管理所有发布平台
 */

import { IPlatformPublisher, PublishResult, PublishOptions } from './publisher-interface';
import { ErrorHandler, PlatformError } from './error-handler';
import { ProgressIndicator } from './progress-indicator';

export class PublisherManager {
    private publishers = new Map<string, IPlatformPublisher>();
    private static instance: PublisherManager;

    private constructor() {}

    static getInstance(): PublisherManager {
        if (!this.instance) {
            this.instance = new PublisherManager();
        }
        return this.instance;
    }

    /**
     * 注册发布平台
     */
    register(publisher: IPlatformPublisher): void {
        this.publishers.set(publisher.id, publisher);
        console.log(`[PublisherManager] 注册发布平台: ${publisher.displayName}`);
    }

    /**
     * 注销发布平台
     */
    unregister(publisherId: string): void {
        if (this.publishers.delete(publisherId)) {
            console.log(`[PublisherManager] 注销发布平台: ${publisherId}`);
        }
    }

    /**
     * 获取所有已注册的发布平台
     */
    getPublishers(): IPlatformPublisher[] {
        return Array.from(this.publishers.values());
    }

    /**
     * 获取指定的发布平台
     */
    getPublisher(publisherId: string): IPlatformPublisher | undefined {
        return this.publishers.get(publisherId);
    }

    /**
     * 检查平台是否可用
     */
    async isPlatformAvailable(publisherId: string): Promise<boolean> {
        const publisher = this.getPublisher(publisherId);
        if (!publisher) {
            return false;
        }

        try {
            return await publisher.validateConfig();
        } catch (error) {
            console.warn(`[PublisherManager] 平台 ${publisherId} 验证失败:`, error);
            return false;
        }
    }

    /**
     * 发布内容到指定平台
     */
    async publish(
        platformId: string, 
        content: string, 
        options?: PublishOptions
    ): Promise<PublishResult> {
        const progress = new ProgressIndicator();
        
        try {
            progress.start(`准备发布到 ${platformId}`);

            const publisher = this.getPublisher(platformId);
            if (!publisher) {
                throw new PlatformError(`发布平台 ${platformId} 未找到`, platformId);
            }

            progress.update('验证平台配置');
            const isValid = await publisher.validateConfig();
            if (!isValid) {
                throw new PlatformError(`发布平台 ${platformId} 配置无效`, platformId);
            }

            progress.update('发布内容');
            const result = await publisher.publish(content, options);

            if (result.success) {
                progress.finish(`发布成功到 ${publisher.displayName}`);
            } else {
                progress.error(`发布失败到 ${publisher.displayName}: ${result.message}`);
            }

            return result;

        } catch (error) {
            const errorMsg = `发布到 ${platformId} 失败`;
            progress.error(errorMsg);
            ErrorHandler.handle(error as Error, 'PublisherManager.publish');
            
            return {
                success: false,
                message: errorMsg,
                error: error as Error
            };
        }
    }

    /**
     * 批量发布到多个平台
     */
    async batchPublish(
        platformIds: string[],
        content: string,
        options?: PublishOptions
    ): Promise<Map<string, PublishResult>> {
        const results = new Map<string, PublishResult>();
        
        console.log(`[PublisherManager] 开始批量发布到 ${platformIds.length} 个平台`);

        for (const platformId of platformIds) {
            try {
                const result = await this.publish(platformId, content, options);
                results.set(platformId, result);
                
                // 添加延迟以避免频率限制
                if (platformIds.length > 1) {
                    await new Promise(resolve => setTimeout(resolve, 2000));
                }
            } catch (error) {
                results.set(platformId, {
                    success: false,
                    message: `批量发布失败: ${error}`,
                    error: error as Error
                });
            }
        }

        const successCount = Array.from(results.values()).filter(r => r.success).length;
        const totalCount = platformIds.length;
        
        console.log(`[PublisherManager] 批量发布完成: ${successCount}/${totalCount} 成功`);
        
        return results;
    }

    /**
     * 生成预览内容
     */
    async generatePreview(
        platformId: string,
        content: string,
        options?: PublishOptions
    ): Promise<string> {
        return await ErrorHandler.withErrorHandling(async () => {
            const publisher = this.getPublisher(platformId);
            if (!publisher) {
                throw new PlatformError(`发布平台 ${platformId} 未找到`, platformId);
            }

            return await publisher.generatePreview(content, options);
        }, 'PublisherManager.generatePreview', '') || '';
    }

    /**
     * 获取平台状态信息
     */
    async getPlatformStatus(): Promise<Map<string, boolean>> {
        const status = new Map<string, boolean>();
        
        for (const [id, publisher] of this.publishers) {
            try {
                const isAvailable = await publisher.validateConfig();
                status.set(id, isAvailable);
            } catch {
                status.set(id, false);
            }
        }
        
        return status;
    }
}