import {
    Node,
    AnimationState,
    director,
    TweenSystem,
    PhysicsSystem2D,
    PhysicsSystem,
    AnimationManager,
    Animation,
} from 'cc';

export class pauseConfig {
    exclude?: Node[];
    recuExclude?: Node[];
}

export default class GameDirector {
    public static pauseData = new (class {
        state = false;
        physics2D: boolean;
        physics3D: boolean;
        scheduler: any[];
        anim: AnimationState[] = [];
        tweenTarget: any[];
    })();

    private static recuNodeList(node: Node, result: Node[] = []): Node[] {
        if (!node) {
            return result;
        }
        result.push(node);
        node.children.forEach((v1) => {
            result.push(v1);
            this.recuNodeList(v1);
        });
        return result;
    }

    public static pause(config?: pauseConfig): void {
        if (GameDirector.pauseData.state) {
            return;
        }

        GameDirector.pauseData.scheduler = director.getScheduler().pauseAllTargets();

        let animSystem = director.getSystem(AnimationManager.ID);
        GameDirector.pauseData.anim.splice(0, GameDirector.pauseData.anim.length, ...animSystem['_anims'].array);
        GameDirector.pauseData.anim.forEach((v1) => {
            v1.pause();
        });

        GameDirector.pauseData.tweenTarget = TweenSystem.instance.ActionManager.pauseAllRunningActions();
        {
            if (PhysicsSystem2D && PhysicsSystem2D.instance.enable) {
                GameDirector.pauseData.physics2D = PhysicsSystem2D.instance.enable;
                PhysicsSystem2D.instance.enable = false;
            }
            if (PhysicsSystem && PhysicsSystem.instance.enable) {
                GameDirector.pauseData.physics3D = PhysicsSystem.instance.enable;
                PhysicsSystem.instance.enable = false;
            }
        }

        if (config) {
            let exclude: Node[] = [];
            exclude.push(...config.exclude);
            config.recuExclude?.forEach((v1) => {
                exclude.push(...GameDirector.recuNodeList(v1));
            });
            exclude.forEach((v1) => {
                GameDirector.resumeNode(v1);
            });
        }
        GameDirector.pauseData.state = true;
    }

    public static resume(): void {
        director.getScheduler().resumeTargets(GameDirector.pauseData.scheduler);
        GameDirector.pauseData.anim.forEach((v1) => {
            if (v1.isPlaying && v1.isPaused) {
                v1.play();
            }
        });

        TweenSystem.instance.ActionManager.resumeTargets(GameDirector.pauseData.tweenTarget);
        if (GameDirector.pauseData.physics2D) {
            PhysicsSystem2D.instance.enable = GameDirector.pauseData.physics2D;
        }
        if (GameDirector.pauseData.physics3D) {
            PhysicsSystem.instance.enable = GameDirector.pauseData.physics3D;
        }
        GameDirector.pauseData.state = false;
    }

    public static pauseNode(node: Node): void;
    public static pauseNode(node: Node[]): void;
    public static pauseNode(args: Node | Node[]): void {
        let node: Node[];
        if (Array.isArray(args)) {
            node = args;
        } else {
            node = [args];
        }
        node.forEach((v1) => {
            director.getScheduler().pauseTarget(v1);
            v1.getComponent(Animation)?.pause();
            TweenSystem.instance.ActionManager.pauseTarget(v1);
        });
    }

    public static resumeNode(node: Node): void;
    public static resumeNode(node: Node[]): void;
    public static resumeNode(args: Node | Node[]): void {
        let node: Node[];
        if (Array.isArray(args)) {
            node = args;
        } else {
            node = [args];
        }
        node.forEach((v1) => {
            director.getScheduler().resumeTarget(v1);
            v1.getComponent(Animation)?.resume();
            TweenSystem.instance.ActionManager.resumeTarget(v1);
        });
    }
}