import { _decorator, Component, instantiate, Node, NodePool, Prefab, resources } from 'cc';
import { PropBase } from './Base/PropBase';
import { FloorType } from '../AutoBuild';
const { ccclass, property } = _decorator;

@ccclass('ObjectPoolManager')
export class ObjectPoolManager extends Component {
    private static _instance: ObjectPoolManager;

    @property({ type: Prefab })
    private prefabs: Prefab[] = [];

    private pools: { [key: string]: NodePool } = {};

    public static getInstance(): ObjectPoolManager {
        if (!ObjectPoolManager._instance) {
            const node = new Node('ObjectPoolManager');
            ObjectPoolManager._instance = node.addComponent(ObjectPoolManager);
        }
        return ObjectPoolManager._instance;
    }

    private prefabPath = [
        'Prefabs/diban',
        'Prefabs/dici',
    ]
    private initPoolNodeCount = [
        3,//prefabPath 每个分别创建多少个
        1,//prefabPath 每个分别创建多少个
    ]

    public async initializePools(): Promise<boolean> {
        return new Promise((resolve, reject) => {
            resources.load(this.prefabPath, (err, prefabs: Prefab[]) => {
                if (err) {
                    console.error(err);
                    reject(err);
                    return;
                }

                prefabs.forEach(prefab => {
                    this.prefabs.indexOf(prefab) == -1 && this.prefabs.push(prefab);
                })

                this.prefabs.forEach(prefab => {
                    const prefabName = prefab.name;
                    this.pools[prefabName] = new NodePool(PropBase);

                    this.initPoolNodeCount.forEach((count) => {
                        for (let index = 0; index < count; index++) {

                            let temp = instantiate(prefab)
                            temp.name = prefabName;
                            this.pools[prefabName].put(temp);
                        }
                    })
                    resolve(true);
                })
            });

        });
    }



    getNodeFromPool(prefabName: FloorType, ParentNode: Node): Node {
        let prefab = this.prefabs.filter(prefab => prefab.name == prefabName);
        if (!prefab) {
            debugger
        }
        if (this.pools[prefabName].size() == 0) {

            let temp = instantiate(prefab[0])
            temp.name = prefabName;
            this.putNodeToPool(temp)
        }
        return this.pools[prefabName].get(ParentNode);
    }

    putNodeToPool(node: Node) {
        this.pools[node.name].put(node);
    }
}