import PlayerMgr from "../object/PlayerMgr";
import GoodsMgr from "../item/GoodsMgr";
import DB from "../utils/DB";
import SKDataUtil from "../gear/SKDataUtil";
import EquipMgr from "../object/EquipMgr";
import GameUtil from "../core/GameUtil";
import BangMgr from "../bang/BangMgr";
import SkillUtil from "../skill/core/SkillUtil";
import ChangeCard from "../object/ChangeCard";
import SKLogger from "../gear/SKLogger";


export default class Ofuda {
    static shared = new Ofuda();
    oflist: any[];
    ofudalist: any[];
    qianjunlist: any[];
    zaiwulist: any[];
    yvshoulist: any[]
    pofuda_map: Map<number, any>;

    constructor() {
        this.oflist = [100321, 100322, 100323]; //待鉴定 千钧符  载物符   御兽符
        this.ofudalist = []; //天策符列表
        this.qianjunlist = []; //千钧符列表
        this.zaiwulist = []; //载物符列表
        this.yvshoulist = []; //御兽符列表
        this.pofuda_map = new Map<number, any>(); //所有玩家的天策符
    }

    init() {
        this.readDB();
    }

    readDB() {
        let sql = `SELECT * FROM qy_ofuda`;
        DB.query(sql, (error: any, rows: any) => {
            for (let i = 0; i < rows.length; i++) {
                if (rows[i].of_type == 1) {
                    this.qianjunlist.push({
                        ofudaid: rows[i].id, //天策符id
                        skillid: rows[i].skillid, //技能id
                        name: rows[i].name, //天策符名字
                        oftype: rows[i].of_type, //天策符类型
                        tier: rows[i].tier, //层数
                    })
                }
                if (rows[i].of_type == 2) {
                    this.zaiwulist.push({
                        ofudaid: rows[i].id, //天策符id
                        skillid: rows[i].skillid, //技能id
                        name: rows[i].name, //天策符名字
                        oftype: rows[i].of_type, //天策符类型
                        tier: rows[i].tier, //层数
                    })
                }
                if (rows[i].of_type == 3) {
                    this.yvshoulist.push({
                        ofudaid: rows[i].id, //天策符id
                        skillid: rows[i].skillid, //技能id
                        name: rows[i].name, //天策符名字
                        oftype: rows[i].of_type, //天策符类型
                        tier: rows[i].tier, //层数
                    })
                }
                this.ofudalist.push({
                    ofudaid: rows[i].id, //天策符id
                    skillid: rows[i].skillid, //技能id
                    name: rows[i].name, //天策符名字
                    oftype: rows[i].of_type, //天策符类型
                    tier: rows[i].tier, //层数
                });
            }
        });

        let starid = 0
        let size = 1000
        let psql = `SELECT roleid,ofuda_data FROM role_has_ofuda where id > ${starid} limit ${size}`;

        let callback = (error: any, rows: any)=>{
            for (let i = 0; i < rows.length; i++) {
                let ofudalist = SKDataUtil.jsonBy(rows[i].ofuda_data);
                if (ofudalist == null || ofudalist == undefined) {
                    continue;
                }
                for (let ofuda of ofudalist) {
                    if (ofuda == null || ofuda == undefined) {
                        continue;
                    }
                    //卸下所有天策符
                    // ofuda.usestate = 0;
                    let roleid = Number(ofuda.roleid); //如果不是int类型，会读取不到
                    if (this.pofuda_map.has(roleid)) {//map里有没有这个key值
                        this.pofuda_map.get(roleid).push(ofuda)
                    } else {
                        let list = [];
                        list.push(ofuda)
                        this.pofuda_map.set(roleid, list);
                    }
                }
            }
            if (rows.length == size){
                starid = starid + size
                psql = `SELECT roleid,ofuda_data FROM role_has_ofuda where id > ${starid} limit ${size}`;
                DB.query(psql, callback);
            }
        }
        DB.query(psql, callback);
    }

    getOfListByRoid(roleid: number) {
        let ofudalist = [];
        let list = this.pofuda_map.get(roleid);
        if (list != undefined){
            for (let ofuda of list) {
                if (ofuda == null || ofuda == undefined) {
                    continue;
                }
                ofudalist.push(ofuda);
            }
        }
        return ofudalist;
    }

    //天策符列表
    getOfudaListByRoid(roleid: number) {
        let player = PlayerMgr.shared.getPlayerByRoleId(roleid);
        let list = this.getOfListByRoid(roleid);
        player.send("s2c_own_ofuda", {list: SKDataUtil.toJson(list, "{}")})
    }

    //天演策列表
    getOfudaList() {
        return this.ofudalist;
    }

    //合成天策符
    compoundOfuda(data: any) {
        let ms1 = new Date().getMilliseconds();
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        let itemData = GoodsMgr.shared.getItemInfo(data.itemid);

        let n = player.getBagItemNum(data.itemid);
        if (n < (itemData.num * data.count)) {
            player.send_notice("碎片数量不足！")
            return;
        }
        let count = 0;
        for (let i = 0; i < data.count; i++) {
            let ofuda = Math.floor(Math.random() * this.oflist.length);
            count += 10;
            player.addBagItem(this.oflist[ofuda], 1, true);
        }
        player.addBagItem(data.itemid, -count, true);
        let ms2 = new Date().getMilliseconds();
        let time = ms2 - ms1;
        SKLogger.info(`合成 - 处理时间${time}ms`)
    }

    //鉴定天策符
    ahcOfuda(data: any) {
        let ms1 = new Date().getMilliseconds();
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        let list = [];
        let olist = [];
        let itemid = 0;
        if (data.ofudatype == 1) {
            itemid = 100321   //待鉴定的千钧符
            olist = this.qianjunlist;
        }
        if (data.ofudatype == 2) {
            itemid = 100322   //待鉴定的载物符
            olist = this.zaiwulist;
        }
        if (data.ofudatype == 3) {
            itemid = 100323   //待鉴定的御兽符
            olist = this.yvshoulist;
        }
        for (let i = 0; i < data.count; i++) {
            let oid = Math.floor(Math.random() * olist.length);
            let ofuda = olist[oid];
            if (ofuda == undefined || ofuda == null) {
                i--;
                continue;
            }
            let ofudaid = Math.random().toString(16).substr(2);  //生成天策符id
            let addition = Math.floor(Math.random() * 10); //加成
            if (addition == 0) {
                addition = 1;
            }
            let grade = 1; //品阶
            let skillid = ofuda.skillid;
            if (ofuda.tier >= 3 && ofuda.tier < 5 && addition >= 8) {
                grade = Math.round(Math.random() * 3);
            } else if (ofuda.tier == 5 && addition >= 6) {
                grade = Math.round(Math.random() * 3);
            } else {
                grade = Math.round(Math.random() * 2);
            }
            if (grade == 0) {
                grade = 1;
            }
            if (grade == 2) {
                skillid += 1;
            } else if (grade == 3) {
                skillid += 2;
            }
            if (skillid == 10205 || skillid == 10206 || skillid == 10207) {//千面符跳过
                i--;
                continue;
            }
            let obj = {
                ofudatype: ofuda.oftype,
                name: ofuda.name, //天策符名字
                grade: grade,
                addition: addition,
                skillid: skillid,
            }
            list.push(obj);
            let ofudaobj = {
                roleid: player.roleid,
                ofudaid: ofudaid, //天策符id
                oftype: ofuda.oftype, //天策符类型
                name: ofuda.name, //天策符名字
                grade: grade, //天策符品阶
                addition: addition, //加成
                skillid: skillid, //技能id
                tier: ofuda.tier, //层数
                usestate: 0, //使用状态
            }
            if (this.pofuda_map.has(player.roleid)) {//map里有没有这个key值
                this.pofuda_map.get(player.roleid).push(ofudaobj)
            } else {
                let list = [];
                list.push(ofudaobj)
                this.pofuda_map.set(player.roleid, list);
            }
        }
        player.addBagItem(itemid, -data.count, true);
        let ms2 = new Date().getMilliseconds();
        let time = ms2 - ms1;
        SKLogger.info(`鉴定 - 处理时间${time}ms`)
        player.send('s2c_authenticate_ofuda', {
            ofudainfo: SKDataUtil.toJson(list, "{}")
        });
    }

    //分解天策符
    resolveOfuda(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        let ofudalist = this.pofuda_map.get(data.roleid);
        if (ofudalist == null || ofudalist == undefined) {
            return;
        }
        for (let key in ofudalist) {
            let ofuda = ofudalist[key];
            if (ofuda == null || ofuda == undefined) {
                continue;
            }
            if (data.ofudaid == ofuda.ofudaid && ofuda.roleid == data.roleid) {
                if (ofuda.grade == 1) {
                    player.addBagItem(100320, 1, true);
                }
                if (ofuda.grade == 2) {
                    player.addBagItem(100320, 5, true);
                }
                if (ofuda.grade == 3) {
                    player.addBagItem(100320, 10, true);
                }
                delete ofudalist[key];
                break;
            }
        }
        this.getOfudaListByRoid(player.roleid);
    }

    //升级天演策
    levelUp(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            if (player.jade < data.jade || player.bangscore < data.score) {
                player.send_notice("仙玉或帮贡不足，升级失败")
                return false;
            }
            if (data.level >= 150) {
                player.send_notice("等级已达到上限！")
                return false;
            }
            let bang = BangMgr.shared.getBang(player.bangid);
            if (bang) {
                let list = bang.rolelist;
                for (let key in list) {
                    if (player.roleid == list[key].roleid) {
                        player.addMoney(GameUtil.goldKind.Jade, -data.jade, "天演策升级");
                        player.addMoney(GameUtil.goldKind.bang_Score, -data.score, "天演策升级");
                        list[key].ofudalevel += data.level;
                        DB.updateBangMemberOfuda(list[key].ofudalevel, player.roleid)
                        player.send_notice(`耗费[${-data.jade}]仙玉、[${-data.score}]帮贡，天演策等级提升到[${list[key].ofudalevel}]级`)
                        return true;
                    }
                }
            }
        }
        return false;
    }

    //装备天策符
    useOfuda(data: any) {
        let ms1 = new Date().getMilliseconds();
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let ofudalist = this.pofuda_map.get(data.roleid);
            if (ofudalist == null || ofudalist == undefined) {
                return;
            }
            let ofuda = null;

            for (let info of ofudalist) {
                if (info == null || info == undefined) {
                    continue;
                }
                if (info.ofudaid == data.ofudaid) {
                    ofuda = info;
                    break;
                }
            }
            if (ofuda == null) {
                player.send_notice("你没有这个天策符");
                return;
            }


            for (let key in ofudalist) {
                let info = ofudalist[key];
                if (info == null || info == undefined) {
                    continue;
                }
                //卸下通用位置的天策符
                if (data.usestate == 3 && ofuda.oftype == info.oftype && data.usestate == info.usestate) {
                    info.usestate = 0;
                    break;
                }
                //根据层数和类型卸下天策符
                if (ofuda.oftype == info.oftype && ofuda.tier == info.tier && data.usestate == info.usestate) {
                    info.usestate = 0;
                }
                //卸下相同的天策符 （相同的天策符只能装备一个）
                if (ofuda.name == info.name && info.usestate > 0) {
                    info.usestate = 0;
                }
            }

            //装备天策符
            for (let key in ofudalist) {
                let info = ofudalist[key];
                if (info == null || info == undefined) {
                    continue;
                }
                if (ofuda.ofudaid == info.ofudaid && data.usestate == 1) { //第一个格子
                    info.usestate = 1;
                    player.calculateAttr();
                    //检查变身卡效果
                    ChangeCard.shared.checkCard(player.roleid);
                    break;
                }
                if (ofuda.ofudaid == info.ofudaid && data.usestate == 2) { //第二个格子
                    info.usestate = 2;
                    player.calculateAttr();
                    //检查变身卡效果
                    ChangeCard.shared.checkCard(player.roleid);
                    break;
                }
                if (ofuda.ofudaid == info.ofudaid && data.usestate == 3) {  //通用位置
                    info.usestate = 3;
                    player.calculateAttr();
                    //检查变身卡效果
                    ChangeCard.shared.checkCard(player.roleid);
                    break;
                }
            }
            let ms2 = new Date().getMilliseconds();
            let time = ms2 - ms1;
            SKLogger.info(`装备 - 处理时间${time}ms`)
        }
    }

    //正在使用的天策符
    inUseOfudaByRoleid(roleid: number) {
        let ofuda_map = new Map<number, any>();
        let ofudalist = this.pofuda_map.get(roleid);
        if (ofudalist == null || ofudalist == undefined) {
            return null;
        }
        for (let ofuda of ofudalist) {
            if (ofuda == null || ofuda == undefined) {
                continue;
            }
            if (ofuda.usestate > 0) {
                ofuda_map.set(ofuda.skillid, ofuda);
            }
        }

        return ofuda_map;
    }

    createOfuda(data: any){
        let ofuda = null;
        for(let info of this.ofudalist){
            if(info.name == data.name){
                ofuda = info;
            }
        }
        if(ofuda == null || ofuda == undefined){
            return null;
        }
        let skillId = ofuda.skillid;
        if (data.grade == 2) {
            skillId += 1;
        }
        if (data.grade == 3) {
            skillId += 2;
        }
        let ofudaid = Math.random().toString(16).substr(2);
        let ofudaobj = {
            roleid: data.roleid,
            ofudaid: ofudaid, //天策符id
            oftype: ofuda.oftype, //天策符类型
            name: data.name, //天策符名字
            grade: data.grade, //天策符品阶
            addition: data.addition, //加成
            skillid: skillId, //技能id
            tier: ofuda.tier, //层数
            usestate: 0, //使用状态
        }
        return ofudaobj;
    }
}