import { HistoryChangedDetail, PlayStatus, PayloadMap, LayerTrimPayload, LayerMovePayload, SingleChangedPayloadMap, HistorySingleChangedDetail } from '../event/types.js';
import { Stage, CalcElementTrimRes, CalcElementPosRes, ElementTypes, Uid, CalcTrackIndexRes, TrackElement, CalcAdsorptionLineRes } from './types.js';

declare class StateManager {
    static instance: StateManager;
    private static clonedTrackItemsMapCache;
    private trackIndexSpacing;
    private adsorptionThreshold;
    private historyCapacity;
    private changedCollections;
    private historyCollections;
    private initState;
    private initHistory;
    private prevState;
    private durationSubject;
    private currentTimeSubject;
    private playStatusSubject;
    private stateSubject;
    private historySubject;
    /**
     *
     * @param state 初始化数据
     * @param options
     *        singleton: 是否启动单例模式
     *        historyCapacity: 历史记录容量
     *        trackIndexSpacing: 轨道间隔，隔默认为2000
     *        adsorptionThreshold: 吸附阈值，不为0则开启
     *        initCallback: 初始化回调
     * @returns
     */
    constructor(state?: Partial<Stage>, options?: {
        singleton?: boolean;
        historyCapacity?: number;
        trackIndexSpacing?: number;
        adsorptionThreshold?: number;
        initCallback?: (data: any) => void;
    });
    static getInstance(state?: Partial<Stage>): StateManager;
    subscribe(callback: (state: Stage) => void): void;
    subscribeHistory(callback: (history: {
        undos: Array<HistoryChangedDetail>;
        redos: Array<HistoryChangedDetail>;
    }) => void): void;
    subscribeCurrentTime(callback: (currentTime: number) => void): void;
    subscribeDuration(callback: (duration: number) => void): void;
    subscribePlayStatus(callback: (status: PlayStatus) => void): void;
    private initListeners;
    handleAction(data: {
        key: keyof PayloadMap;
        value: any;
        callback?: (value: any) => void;
    }, needCollectChanges?: boolean): void;
    private getClonedTrackItemsMap;
    /**
     * 计算元素裁切
     * @param data
     * @param needOrganizeElements: 是否需要整理元素位置（主轨道需要整理）
     * @param stageData: 舞台数据
     * @returns trackItemsMapChanged: 数据发生变化的元素
     */
    calcElementTrim(data: LayerTrimPayload, needOrganizeElements?: boolean, stageData?: Stage): CalcElementTrimRes | undefined;
    /**
     * 计算元素位置
     * @param data
     * @param stageData
     * @returns curTrack: 当前轨道
     *          originTrack: 原始轨道
     *          trackItemsMapChanged: 数据发生过变化的元素
     */
    calcElementPos(data: LayerMovePayload, stageData?: Stage): CalcElementPosRes | undefined;
    /**
     * 轨道层级计算
     * @param data
     * @returns zIndex: 内部计算得到的层级, position: 当前元素在数组中的位置
     */
    calcTrackIndex(params: {
        payload: {
            type: ElementTypes;
            isMain: boolean;
            index?: number;
            layerId?: Uid;
        };
    }): CalcTrackIndexRes;
    /**
     * 吸附线计算
     * @param data id: 拖动的元素id, startPos: 元素拖动的位置
     * @returns startPos: 吸附后的元素位置, adsorptionLines: 应该显示的吸附线
     */
    calcAdsorptionLine(data: {
        id: Uid;
        startPos: number;
        layerData?: TrackElement;
    }, stageData?: Stage): CalcAdsorptionLineRes | undefined;
    getState(): Stage;
    getHistory(): {
        undos: Array<HistoryChangedDetail>;
        redos: Array<HistoryChangedDetail>;
    };
    dispatchChanged<K extends keyof SingleChangedPayloadMap = keyof SingleChangedPayloadMap>(key: K, value: PayloadMap[K] & {
        callback?: () => void;
    }, needCollectChanges?: boolean): void;
    getStageDuration(state: Stage): number;
    updateState(newState: Stage): void;
    updateHistory(diff: HistorySingleChangedDetail['diff'], type: keyof PayloadMap, needCollectHistory?: boolean): void;
    /**
     * 撤销
     * @param stepNums 撤销步数
     */
    undo(stepNums?: number): void;
    /**
     * 重做
     * @param stepNums 重做步数
     */
    redo(stepNums?: number): void;
    resetHistory(): void;
    changeAdsorptionThreshold(value: number): void;
}

export { StateManager };