import { Application } from '@eva/renderer-adapter';
import type { ApplicationOptions } from 'pixi.js';
import { ComponentChanged } from '@eva/eva.js';
import { Container } from '@eva/renderer-adapter';
import EventEmitter from 'eventemitter3';
import { Game } from '@eva/eva.js';
import { GameObject } from '@eva/eva.js';
import { LOAD_SCENE_MODE } from '@eva/eva.js';
import { PureObserverInfo } from '@eva/eva.js';
import { Scene } from '@eva/eva.js';
import { System } from '@eva/eva.js';
import { Transform } from '@eva/eva.js';
import { UpdateParams } from '@eva/eva.js';

export declare class ContainerManager {
    containerMap: {
        [propName: number]: Container;
    };
    addContainer({ name, container, gameObject }: {
        name: number;
        container: Container;
        gameObject: GameObject;
    }): void;
    getContainer(name: number): Container;
    removeContainer(name: number): void;
    updateTransform({ name, transform }: {
        name: number;
        transform: Transform;
    }): void;
}

declare interface Params {
    jsUrl: string;
    wasmUrl: string;
}

export declare function registerKtx2CompressedTexture(params: Params): void;

export declare class Renderer<T extends {} = {}> extends System<T> {
    /**
     * Renderer name
     */
    name: string;
    /**
     * currentGame
     */
    game: Game;
    /**
     * observer component props info
     */
    static observerInfo: PureObserverInfo;
    /**
     * observer component props info
     */
    observerInfo: PureObserverInfo;
    /**
     * containerManager
     */
    containerManager: ContainerManager;
    rendererManager: RendererManager;
    constructor(params?: T);
    /**
     * 当监听的属性变化时候调用
     *
     * called while the observed component props change.
     */
    componentChanged(_changed: ComponentChanged): void;
    /**
     * 每帧调用
     *
     * called by every loop
     * @param _gameObject gameObject
     */
    rendererUpdate(_gameObject: GameObject): void;
    update(e?: UpdateParams): void;
    protected asyncIdMap: Record<number, number>;
    protected increaseAsyncId(id: number): number;
    protected validateAsyncId(id: number, asyncId: number): boolean;
}

export declare enum RENDERER_TYPE {
    UNKNOWN = 0,
    WEBGL = 1,
    CANVAS = 2
}

/**
 * 渲染管理器类
 *
 * RendererManager 负责管理和协调所有渲染器。
 * 它将组件变化事件分发给相应的渲染器，
 * 并在每帧调用渲染器的更新方法。
 *
 * @example
 * ```typescript
 * const rendererManager = new RendererManager({
 *   game,
 *   rendererSystem
 * });
 *
 * rendererManager.register(
 *   new SpriteRenderer(),
 *   new TextRenderer()
 * );
 * ```
 */
export declare class RendererManager {
    /** 游戏实例引用 */
    game: Game;
    /** 渲染系统引用 */
    rendererSystem: RendererSystem;
    /**
     * 构造渲染管理器
     * @param game - 游戏实例
     * @param rendererSystem - 渲染系统实例
     */
    constructor({ game, rendererSystem }: {
        game: any;
        rendererSystem: any;
    });
    /** 注册的渲染器列表 */
    renderers: Renderer[];
    /**
     * 注册渲染器
     *
     * 将渲染器添加到管理器，并为其设置必要的引用。
     *
     * @param renderers - 要注册的渲染器列表
     */
    register(...renderers: Renderer[]): void;
    componentChanged(changes: ComponentChanged[]): void;
    update(gameObject: GameObject): void;
}

export declare class RendererSystem extends System<RendererSystemParams> {
    static systemName: string;
    params: Partial<RendererSystemParams>;
    rendererManager: RendererManager;
    containerManager: ContainerManager;
    application: Application;
    game: Game;
    transform: Transform_2;
    multiApps: Application[];
    suportedCompressedTextureFormats: SuportedCompressedTexture;
    init(params: Partial<RendererSystemParams>): Promise<void>;
    registerObserver(observerInfo: any): void;
    createMultiApplication({ params }: {
        params: RendererSystemParams;
    }): Promise<Application>;
    createApplication(params: Partial<RendererSystemParams>): Promise<Application>;
    update(): void;
    lateUpdate(e: any): void;
    onDestroy(): void;
    resize(width: any, height: any): void;
    private getApplicationByScene;
    private onPauseScene;
    private onStartScene;
    resizeByScene(scene: any, width: number, height: number): void;
}

export declare interface RendererSystemParams extends Partial<ApplicationOptions> {
    canvas?: HTMLCanvasElement;
    renderType?: number;
    enableScroll?: boolean;
    debugMode?: boolean;
}

declare interface SuportedCompressedTexture {
    s3tc: boolean;
    etc: boolean;
    etc1: boolean;
    pvrtc: boolean;
    atc: boolean;
    astc: boolean;
}

declare class Transform_2 extends EventEmitter {
    name: string;
    waitRemoveIds: number[];
    waitSceneId: number;
    system: RendererSystem;
    containerManager: ContainerManager;
    waitChangeScenes: {
        scene: Scene;
        mode: LOAD_SCENE_MODE;
        application: Application;
    }[];
    constructor({ system, containerManager }: {
        system: any;
        containerManager: any;
    });
    init(system: RendererSystem): void;
    update(): void;
    componentChanged(changed: ComponentChanged): void;
    addContainer(changed: ComponentChanged): void;
    change(changed: ComponentChanged): void;
    destroy(): void;
}

export { }