import DataObj from "../../configData/DataObj";
import { TowerType } from "../../configData/Enum";
import GameConfig from "../../configData/GameConfig";
import gameUI from "../UIFace/gameUI";
import monsterManger from "../monster/monsterManger";
import monsterNode from "../monster/monsterNode";

import arrow from "./arrow";
import barracks from "./barracks";
import Magic from "./Magic";
import taside from "./taside";
import TowerData from "./TowerData";
import TowerHuan from "./TowerHuan";
import turret from "./turret";
import gameData from "../../configData/gameData";
import buildload from "./buildload";

const { ccclass, property } = cc._decorator;

@ccclass
export default class towerManger extends cc.Component {

    /**塔集合 */
    public towerArr = [];

    private towerpos: cc.Vec2[] = [];

    private mynitu: cc.Node[] = [];
    private mytaside: taside[] = [];
    private towerHuan: TowerHuan[] = [];

    public myDataObj: DataObj = null;
    public static instance: towerManger = null;
    /**天赋数值 */
    public talantData = [];
    protected onLoad() {
        towerManger.instance = this;
        this.myDataObj = new DataObj();
    }

    start() {
        // console.log("--------------------towerManger");
    }

    /**初始化数据 */
    private resetData() {
        for (let i = 0; i < this.mynitu.length; i++) {
            const element = this.mynitu[i];
            element.destroy();
        }
        this.mynitu = [];

        for (let i = 0; i < this.mytaside.length; i++) {
            const element = this.mytaside[i];
            element.node.destroy();
        }
        this.mytaside = [];
        for (let i = 0; i < this.towerArr.length; i++) {
            const element = this.towerArr[i];
            element.node.destroy();
        }
        this.towerArr = [];

        this.inittalantData();
        gameUI.instance.openSkillBtn();
    }
    /**加载泥土 */
    public initTowerTaside() {
        this.resetData();
        this.towerpos = TowerData.instance().getTowerPos(gameUI.instance.myDataObj.LevelData.scene_path);
        var self = this;

        cc.resources.load("gamebg/taside_" + gameUI.instance.myDataObj.LevelData.map_type, cc.SpriteFrame, function (err, myspriteFrame: cc.SpriteFrame) {
            for (let i = 0; i < self.towerpos.length; i++) {
                const element = self.towerpos[i];
                let mynode = new cc.Node();
                let spr = mynode.addComponent(cc.Sprite);
                spr.spriteFrame = myspriteFrame;
                mynode.setPosition(element);
                self.node.addChild(mynode);
                self.mynitu.push(mynode);
            }
        });

        cc.resources.load("prefabs/taside", cc.Prefab, function (err, prefab: cc.Prefab) {

            for (let i = 0; i < self.towerpos.length; i++) {
                const element = self.towerpos[i];
                var newNode = cc.instantiate(prefab);
                self.node.addChild(newNode, 1006);
                newNode.setPosition(element);
                self.mytaside.push(newNode.getComponent(taside));
            }
        });
    }

    /**创建塔选项环 */
    private initTowerHuan(type: TowerType, taTs) {
        var self = this;
        cc.resources.load("prefabs/taHuan", cc.Prefab, function (err, prefab: cc.Prefab) {
            var newNode = cc.instantiate(prefab);
            self.node.addChild(newNode, 1006);
            newNode.setPosition(taTs._taside.node.getPosition().add(cc.v2(0, 45)));
            let mytahuan = newNode.getComponent(TowerHuan);
            mytahuan.setTowerType(type);
            mytahuan.setTower(taTs);
            taTs.setTaHuan(mytahuan);
            self.towerHuan.push(mytahuan);

            if (self.myDataObj.TowerData.tower_level != 1) {
                self.towerArr.push(taTs);
            }

        });
    }

    /**关闭已打开的选择环 */
    public closedHuan() {
        for (let i = 0; i < this.mytaside.length; i++) {
            const element = this.mytaside[i];
            if (element.isOpen) {
                element.turnsmall();
            }
        }

        for (let i = 0; i < this.towerHuan.length; i++) {
            const element = this.towerHuan[i];
            if (element.node == null) {
                this.towerHuan.splice(i, 1);
                i--;
                continue;
            }
            if (element.isOpen) {
                element.turnsmall();
            }
        }
    }

    /**传入插旗点 */
    public chaqiGetPos(loca: cc.Vec2) {
        for (let i = 0; i < this.towerHuan.length; i++) {
            const element = this.towerHuan[i];
            if (element.node == null) {
                this.towerHuan.splice(i, 1);
                i--;
                continue;
            }
            element.chaqiTap(loca);
        }
    }

    /**修建塔 */
    public buildTower(mytaside: taside, ID: number, solarr: cc.Vec2[], isBuild: boolean) {
        var self = this;
        this.myDataObj.writeTower_Config(ID);
        mytaside.ClosedTouch();
        cc.resources.load("prefabs/" + this.myDataObj.TowerData.name1, cc.Prefab, function (err, prefab: cc.Prefab) {
            var newNode = cc.instantiate(prefab);
            let calssName = null;
            let judgevec: cc.Vec2 = mytaside.node.getPosition();
            switch (self.myDataObj.TowerData.tower_type) {
                case 1:
                    calssName = newNode.getComponent(arrow);
                    judgevec = judgevec.add(cc.v2(-1, 40));
                    break;
                case 2:
                    calssName = newNode.getComponent(Magic);
                    judgevec = judgevec.add(cc.v2(-1, -19));
                    break;
                case 3:
                    calssName = newNode.getComponent(turret);
                    judgevec = judgevec.add(cc.v2(-1, -24));
                    break;
                case 4:
                    {
                        calssName = newNode.getComponent(barracks);
                        judgevec = judgevec.add(cc.v2(5, 30));
                        if (solarr.length > 0) {
                            calssName.setSoldePosArr(solarr);
                        }
                    }
                    break;

                default:
                    break;
            }
            newNode.setPosition(judgevec);
            newNode.scale = self.myDataObj.TowerData.model_scaling;
            self.node.addChild(newNode, Math.floor((540 - judgevec.y) / 10));
            calssName.setNitu(mytaside);
            calssName.initID(ID);
            calssName.towerType = self.myDataObj.TowerData.tower_type;
            self.initTowerHuan(self.myDataObj.TowerData.tower_type, calssName);

            newNode.active = false;
            if (isBuild) {
                newNode.opacity = 0;
                cc.tween(newNode)
                    .delay(Number(gameData.instance().game_Const[1][2]) - 0.03)
                    .to(0.03, { opacity: 255 })
                    .call(() => {
                        newNode.active = true;
                        self.towerArr.push(calssName);
                    })
                    .start();
            }
            else {
                newNode.active = true;
            }


        });

        if (isBuild) {
            this.buildload(mytaside);
        }
    }
    /**升级塔 */
    public UpTower(tower, nextid: number) {
        tower._taside.addtowerGold(tower.myDataObj.TowerData.up_gold[0]);
        let arr = [];
        if (tower.towerType == 4) {
            arr = tower.getSoldePosArr();
        }
        this.buildTower(tower._taside, nextid, arr, false);
    }

    /**建塔进度条显示 */
    private buildload(mytaside: taside) {
        let self = this;
        cc.resources.load("prefabs/buildLoad", cc.Prefab, function (err, prefab: cc.Prefab) {
            var newNode = cc.instantiate(prefab);
            mytaside.node.addChild(newNode, 1005);
            newNode.setPosition(cc.v2(0, 0));
        });
    }


    /**
     * 求C到直线AB得距离
     * @param C 直线外一点
     * @param A 直线上一点
     * @param B 直线上一点
     */
    public pointToLineDistance(C: cc.Vec2, A: cc.Vec2, B: cc.Vec2): number {
        let dx = B.x - A.x;
        let dy = B.y - A.y;
        let d = dx * dx + dy * dy;
        let D: cc.Vec2 = cc.v2();
        if (d === 0) { // |AB| = 0，说明A与B共点
            D = A;
        } else {
            let q = ((C.x - A.x) * dx + (C.y - A.y) * dy) / d; // 求出q得值
            D = cc.v2(A.x + q * dx, A.y + q * dy);// 得到D得坐标
        }
        dx = D.x - C.x;
        dy = D.y - C.y;
        return Math.sqrt(dx * dx + dy * dy);
    }

    /**箭塔激光击中的怪减血 A开始点   B目标点之一   attnum攻击力   magicLeth激光爆炸范围*/
    public MagicAttckMonster(A: cc.Vec2, B: cc.Vec2, attnum: number, magicLeth: number) {
        let monarr = monsterManger.instance.GetMonsterArr();
        for (let k = 0; k < monarr.length; k++) {
            const minster = monarr[k];
            if (minster.getIsdie()) {
                continue;
            }
            let C: cc.Vec2 = minster.getNewPos();

            let juli = this.pointToLineDistance(C, A, B);

            if (juli < magicLeth && C.sub(A).mag() > C.sub(B).mag()) {
                minster.hpDown(attnum * (1 - minster.myDataObj.monsterData.magic_reduction));
                minster.MagicCutPhysicsreduction();
            }
        }
    }

    /**删除已销毁的塔 */
    public delateTower(tower) {
        for (let i = 0; i < this.towerArr.length; i++) {
            const myarrow = this.towerArr[i];
            if (myarrow == tower) {
                this.towerArr.splice(i, 1);
                return;
            }
        }
    }

    /**设置怪物走路是否一直走  true:停*/
    public setAniGo(isGo: boolean) {
        let monarr = monsterManger.instance.GetMonsterArr();
        for (let k = 0; k < monarr.length; k++) {
            const minster = monarr[k];
            minster.SetWalk(isGo);
        }

        //兵塔
        for (let i = 0; i < this.towerArr.length; i++) {
            const myarrow = this.towerArr[i];
            if (myarrow.towerType == 4) {
                myarrow.isPaused(isGo);
            }
        }
    }

    /**刷新坐标查看塔周围动静添加定时器 */
    public updateTowerActionSchle() {
        this.schedule(this.updateTowerAction, 0.1);
    }
    /**刷新坐标查看塔周围动静 */
    private updateTowerAction() {
        let monarr = monsterManger.instance.GetMonsterArr();
        if (monarr.length == 0 && monsterManger.instance.getIsCanOver()) {
            monsterManger.instance.isGameOver();
            this.unschedule(this.updateTowerAction);
        }
        // console.log("刷新："+monarr.length);
        for (let k = 0; k < monarr.length; k++) {
            const minster = monarr[k];
            if (minster.node == null) {
                monarr.splice(k, 1);
                k--;
                continue;
            }

            let posy = minster.node.getPosition().y;
            minster.node.zIndex = Math.floor((540 - posy) / 10);

            //塔
            for (let i = 0; i < this.towerArr.length; i++) {
                const myarrow = this.towerArr[i];
                if (myarrow.getIsInSqrt(minster.node.getPosition())) {
                    let index = myarrow.getAttackmonster().indexOf(minster);
                    if (index < 0) {
                        myarrow.addAttackmonster(minster);
                        if (myarrow.getAttackmonster().length == 1) {
                            myarrow.attckStart();
                        }
                    }
                }
            }
        }

    }


    /**天赋数值读取 */
    private inittalantData() {
        this.talantData = [];
        for (let i = 0; i < 30; i++) {
            let temparr: number[] = [];
            if (GameConfig.instance().storageData.myTalant[i] == 1) {
                this.myDataObj.writeTalent_Config(i + 1);
                temparr.push(this.myDataObj.talentData.parameter_2);
                temparr.push(this.myDataObj.talentData.parameter_3);
                temparr.push(this.myDataObj.talentData.parameter_4);
                temparr.push(this.myDataObj.talentData.parameter_5);
            }
            this.talantData.push(temparr);
        }
    }


}