/**
 * @webrtc2/config
 * 
 * Configuration management for WebRTC2 ecosystem
 */

import type { RTCConnectionConfig } from '@webrtc2/types';

export interface WebRTC2Config {
    // Connection settings
    rtc: RTCConnectionConfig;

    // Signaling server
    signaling: {
        url: string;
        reconnectAttempts: number;
        reconnectDelay: number;
    };

    // Media settings
    media: {
        video: {
            width: number;
            height: number;
            frameRate: number;
            facingMode?: 'user' | 'environment';
        };
        audio: {
            echoCancellation: boolean;
            noiseSuppression: boolean;
            autoGainControl: boolean;
        };
    };

    // UI settings
    ui: {
        theme: 'light' | 'dark' | 'auto';
        language: string;
        showStats: boolean;
    };

    // Debug settings
    debug: {
        enabled: boolean;
        level: 'debug' | 'info' | 'warn' | 'error';
        logToConsole: boolean;
    };
}

// Default configuration
export const defaultConfig: WebRTC2Config = {
    rtc: {
        iceServers: [
            { urls: 'stun:stun.l.google.com:19302' },
            { urls: 'stun:stun1.l.google.com:19302' }
        ],
        bundlePolicy: 'balanced',
        rtcpMuxPolicy: 'require'
    } as RTCConnectionConfig,

    signaling: {
        url: 'wss://signaling.webrtc2.com',
        reconnectAttempts: 5,
        reconnectDelay: 1000
    },

    media: {
        video: {
            width: 1280,
            height: 720,
            frameRate: 30,
            facingMode: 'user'
        },
        audio: {
            echoCancellation: true,
            noiseSuppression: true,
            autoGainControl: true
        }
    },

    ui: {
        theme: 'auto',
        language: 'en',
        showStats: false
    },

    debug: {
        enabled: false,
        level: 'info',
        logToConsole: true
    }
};

// Configuration manager
export class ConfigManager {
    private config: WebRTC2Config;

    constructor(initialConfig?: Partial<WebRTC2Config>) {
        this.config = this.mergeConfig(defaultConfig, initialConfig || {});
    }

    private mergeConfig(base: WebRTC2Config, override: Partial<WebRTC2Config>): WebRTC2Config {
        return {
            rtc: { ...base.rtc, ...override.rtc },
            signaling: { ...base.signaling, ...override.signaling },
            media: {
                video: { ...base.media.video, ...override.media?.video },
                audio: { ...base.media.audio, ...override.media?.audio }
            },
            ui: { ...base.ui, ...override.ui },
            debug: { ...base.debug, ...override.debug }
        };
    }

    get(): WebRTC2Config {
        return { ...this.config };
    }

    update(updates: Partial<WebRTC2Config>): void {
        this.config = this.mergeConfig(this.config, updates);
    }

    reset(): void {
        this.config = { ...defaultConfig };
    }

    // Specific getters for common use cases
    getRTCConfig(): RTCConnectionConfig {
        return { ...this.config.rtc };
    }

    getSignalingUrl(): string {
        return this.config.signaling.url;
    }

    getMediaConstraints(): MediaStreamConstraints {
        return {
            video: {
                width: this.config.media.video.width,
                height: this.config.media.video.height,
                frameRate: this.config.media.video.frameRate,
                facingMode: this.config.media.video.facingMode
            },
            audio: {
                echoCancellation: this.config.media.audio.echoCancellation,
                noiseSuppression: this.config.media.audio.noiseSuppression,
                autoGainControl: this.config.media.audio.autoGainControl
            }
        };
    }
}

// Default config manager instance
export const config = new ConfigManager();

// Helper functions
export function createConfig(overrides?: Partial<WebRTC2Config>): ConfigManager {
    return new ConfigManager(overrides);
}

export function validateConfig(config: Partial<WebRTC2Config>): boolean {
    // Basic validation - can be extended
    if (config.signaling?.url && !config.signaling.url.startsWith('ws')) {
        return false;
    }

    if (config.media?.video?.width && config.media.video.width <= 0) {
        return false;
    }

    return true;
}

export const VERSION = '1.0.0';