import { UserModel } from '@db/User';
import { RoleModel } from '@db/Role';
import Hero, { HeroModel } from '@db/Hero';
import { EquipModel } from '@db/Equip';
import { ActionPointModel } from '@db/ActionPoint';
import { BattleDropModel } from '@db/BattleDrop';
import { BattleRecordModel } from '@db/BattleRecord';
import { BattleSweepRecordModel } from '@db/BattleSweepRecord';
import { DailyRecordModel } from '@db/DailyRecord';
import { EventRecordModel } from '@db/EventRecord';
import { ExpeditionPointModel } from '@db/ExpeditionPoint';
import { ExpeditionRecordModel } from '@db/ExpeditionRecord';
import { ExpeditionWarRecordModel } from '@db/ExpeditionWarRecord';
import { HangUpRecordModel } from '@db/HangUpRecord';
import { HangUpSpdUpRecModel } from '@db/HangUpSpdUpRec';
import { SearchRecordModel } from '@db/SearchRecord';
import { TowerRecordModel } from '@db/TowerRecord';
import { TowerTaskRecModel } from '@db/TowerTaskRec';
import { PvpDefenseModel } from '@db/PvpDefense';

import { Service } from 'egg';
import Counter from '@db/Counter';
import { STATUS, HERO_SYSTEM_TYPE } from '@consts';
import { ITID, COUNTER } from '@consts';
import Actor from '@pubUtils/actor';
import { ItemModel } from '@db/Item';
import { gameData } from '@pubUtils/data';
import { calPlayerCeAndSave } from '@pubUtils/playerCe';

/**
 * Test Service
 */
export default class GMUsers extends Service {

  /**
   * 根据类型等搜索玩家
   */
  public async getuserlist(field, value) {
    const {ctx} = this;

    let arr = new Array(), flag = 0;
    value = value.split(',');
    for(let i of value) {
        if(field == 'uid') {
            let d = parseInt(i);
            if(isNaN(d)) {
                flag = 1; break;
            } else {
                arr.push(d);
            }
        } else if(field == 'username'||field == 'tel') {
            arr.push(i);
        } else if (field == 'all') {
            break;
        } else {
            flag = 1; break;
        }
    }
    
    if(flag) {
        return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
    }

    let users = await UserModel.findUserByField(field, value);

    if(users) {
        let list = new Array();
        for(let user of users) {
            let role = await RoleModel.findByUid(user.uid, 1);
            list.push({...user, hasRole: role?true: false, role});
        }

        return ctx.service.utils.resResult(STATUS.SUCCESS, {list})
    } else {
        console.error('userlist not found');
        return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
    }
  }

  public async createRole(uid:number, serverId: number, roleName: string) {
    console.log('enter Auth createRole');
    const ctx = this.ctx;

    const roleId = ctx.service.utils.genCode(10);
    const code = ctx.service.utils.genCode(6);
    const seqId = await Counter.getNewCounter(COUNTER.ROLE) || -1;
    const role = await RoleModel.createRole(uid, serverId, { roleId, code, roleName, seqId });
    if (role) {
        return ctx.service.utils.resResult(STATUS.SUCCESS);
    } else {
        console.error('create role error');
        return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
    }
  }

  public async deleteRole(roleId: string) {
    console.log('enter Auth deleteRole');
    const ctx = this.ctx;
    await ActionPointModel.deleteAccount(roleId);
    await BattleDropModel.deleteAccount(roleId);
    await BattleRecordModel.deleteAccount(roleId);
    await BattleSweepRecordModel.deleteAccount(roleId);
    await DailyRecordModel.deleteAccount(roleId);
    await EquipModel.deleteAccount(roleId);
    await EventRecordModel.deleteAccount(roleId);
    await ExpeditionPointModel.deleteAccount(roleId);
    await ExpeditionRecordModel.deleteAccount(roleId);
    await ExpeditionWarRecordModel.deleteAccount(roleId);
    await HangUpSpdUpRecModel.deleteAccount(roleId);
    await HangUpRecordModel.deleteAccount(roleId);
    await HeroModel.deleteAccount(roleId);
    await RoleModel.deleteAccount(roleId);
    await SearchRecordModel.deleteAccount(roleId);
    await TowerTaskRecModel.deleteAccount(roleId);
    await TowerRecordModel.deleteAccount(roleId);
    await PvpDefenseModel.deleteAccount(roleId);

    return ctx.service.utils.resResult(STATUS.SUCCESS);
  }



  /**
   * 根据类型等搜索玩家
   */
  public async getrolelist(field, value) {
    const {ctx} = this;

    let arr = new Array(), flag = 0;
    value = value.split(',');
    for(let i of value) {
        if(field == 'uid') {
            let d = parseInt(i);
            if(isNaN(d)) {
                flag = 1; break;
            } else {
                arr.push(d);
            }
            field = 'userInfo.uid';
        } else if(field == 'roleName') {
            arr.push(i);
        } else if (field == 'tel') {
            arr.push(i);
            field = 'userInfo.tel';
        } else if (field == 'all') {
            break;
        } else {
            flag = 1; break;
        }
    }
    
    if(flag) {
        return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
    }

    let roles = await RoleModel.findRoleByField(field, value);

    if(roles) {

        let result = new Array();
        for(let role of roles) {
            let heroCount = await HeroModel.count({roleId: role.roleId}).lean();
            let equipCount = await EquipModel.count({roleId: role.roleId}).lean();
            let itemCount = await ItemModel.count({roleId: role.roleId}).lean();
            let defense = await PvpDefenseModel.findByRoleId(role.roleId);

            let {roleId, roleName, serverId, lv, vLv, gold, coin} = role;
            let {uid, tel} = role.userInfo;
            result.push({
                key: roleId, roleId, roleName, serverId, lv, vLv, uid, tel, heroCount, equipCount, itemCount, gold, coin,
                hasDefense: defense?'是':'否', defCe: defense?defense.ce:0
            });
        }
        return ctx.service.utils.resResult(STATUS.SUCCESS, { list: result });
    } else {
        console.error('role list not found');
        return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
    }
  }

  public async createHero(uids: Array<string>, _hid: string, _hlv: string) {
    const {ctx} = this;
    console.log('gm createHero', uids, _hid, _hlv);
    let hlv = parseInt(_hlv);
    if( isNaN(hlv)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
    let hids = (_hid as string).split('&').map(cur => parseInt(cur));
    for(let hid of hids) {
        if(isNaN(hid)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
    }

    let heroInfos = new Array();
    for(let roleId of uids) {
        let role = await RoleModel.findByRoleId(roleId);
        if(role) {
            for(let hid of hids) {
                let hero = await HeroModel.findByHidAndRole(hid, roleId);
                if(hero) continue;
                let dicHero = ctx.service.utils.getHeroById(hid);
                if(!dicHero) continue;  
                let {quality, initialStars: star, jobid: job, name: hName, initialSkin} = dicHero;
                const heroInfo = {
                    roleId, roleName: role.roleName, hid, hName, star, quality, job, serverId: role.serverId,
                    lv: hlv,
                    skins:[{id: initialSkin, enable: true}],
                }
                heroInfos.push(heroInfo);
            }
        } else {
            return ctx.service.utils.resResult(STATUS.GM_CREATE_ERROR, null, '未找到角色' + roleId)
        }
    }

    try {
        for(let heroInfo of heroInfos) {
            let hero = await HeroModel.createHero(heroInfo);
            await calPlayerCeAndSave(heroInfo.roleId, [hero], HERO_SYSTEM_TYPE.INIT);
        }
        return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
    } catch(e) {
        console.error(e.stack)
    }
  }

  public async createEquip(uids: Array<string>, _eid: string, _ecount: string, _ehid: string) {
    const {ctx} = this;
    console.log('gm createEquip', uids, _eid, _ecount, _ehid);
    let eid = parseInt(_eid);
    let ecount = parseInt(_ecount);
    let ehid = parseInt(_ehid);
    if(isNaN(eid) || isNaN(ecount) || isNaN(ehid)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);

    let flag = 0, msg = '创建失败';
    for(let roleId of uids) {
        let role = await RoleModel.findByRoleId(roleId);
        if(role) {
            for(let i = 0; i <ecount; i++) {

                let dicEquip = gameData.goods.get(eid);
                if(!dicEquip) {
                    flag = 1, msg = "未找到装备" + eid;
                    break;
                }
                await ctx.service.utils.addEquips(roleId, role.roleName, {id: eid, ...dicEquip, hid: ehid});
            }
        } else {
            flag = 1, msg = '未找到角色' + roleId;
        }
    }

    if (flag) {
        return ctx.service.utils.resResult(STATUS.GM_CREATE_ERROR, null, msg);
    } else {
        return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
    }
  }

  public async createItem(uids: Array<string>, _itemid: string, _itemcount: string) {
    const {ctx} = this;
    console.log('gm createItem', uids, _itemid, _itemcount);
    let itemid = parseInt(_itemid);
    let itemcount = parseInt(_itemcount);
    if(isNaN(itemid) || isNaN(itemcount)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
    let dicGoods = gameData.goods.get(itemid);
    let itidObj = ITID.get(dicGoods.itid);

    let flag = 0, msg = '创建失败';
    if(!dicGoods) {
        flag = 1, msg = "未找到道具" + itemid;
    } else if(!itidObj){
        flag = 1, msg = "未找到道具" + itemid;
    } else {
        for(let roleId of uids) {
            let role = await RoleModel.findByRoleId(roleId);
            if(role) {
                await ctx.service.utils.addBags(roleId, role.roleName, {id: itemid, itemName: dicGoods.name, count: itemcount, type: itidObj.type, hid: 0});
            } else {
                flag = 1, msg = '未找到角色' + roleId;
            }
        }
    }

    if (flag) {
        return ctx.service.utils.resResult(STATUS.GM_CREATE_ERROR, null, msg);
    } else {
        return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
    }
  }

  public async addGold(uids: Array<string>, _count: string) {
    const {ctx} = this;
    console.log('gm addGold', uids, _count);
    let count = parseInt(_count);
    if(isNaN(count)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
    for(let roleId of uids) {
        await RoleModel.addGoldFree(roleId, count);
    }

    return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
  }

  public async addSkins(uids: Array<string>, _id: string) {
    const {ctx} = this;
    console.log('gm addSkin', uids, _id);
    let id = parseInt(_id);
    if(isNaN(id)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
    for(let roleId of uids) {
        await ctx.service.utils.addSkins(roleId, id);
    }

    return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
  }

  public async levelUp(uids: Array<string>, _lv: string) {
    const {ctx} = this;
    console.log('gm levelUp', uids, _lv);
    let lv = parseInt(_lv);
    if(isNaN(lv)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
    for(let roleId of uids) {
        let exp = ctx.service.utils.getExpByLv(lv);
        await RoleModel.levelup(roleId, lv, exp?exp.sum:0);
    }

    return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
  }

  public async getPvpDefense(roleId: string) {
    const {ctx} = this;
    let result = await PvpDefenseModel.findByRoleId(roleId);
    return ctx.service.utils.resResult(STATUS.SUCCESS, {
        hasDefense: !!result, defense: result
    })
  }

  public async getHeroList(roleId: string) {
    const {ctx} = this;
    let herolist = await HeroModel.findByRole(roleId);
    let defense = await PvpDefenseModel.findByRoleId(roleId);
    
    let result = Array<Hero>();
    for(let hero of herolist) {
        if(defense) {
            let {heroes = []} = defense;
            let curHero = heroes.find(cur => cur.actorId == hero.hid);
            if(!curHero) {
                result.push(hero);
            }
        } else{
            result.push(hero);
        }
    }

    return ctx.service.utils.resResult(STATUS.SUCCESS, {
        heroes: result
    })
  }

  public async saveHeroToDefense(roleId: string, roleName: string, hid: number) {
      const {ctx} = this;
      let hero = await HeroModel.findByHidAndRole(hid, roleId);
      if(!hero) {
          return ctx.service.utils.resResult(STATUS.GM_HERO_NOT_FOUND);
      }
      let { lv } = hero;

      let dicHero = ctx.service.utils.getHeroById(hid);

      let actor = new Actor();
      actor.initHero(hero);
      let ce = actor.calculateCE();
      let attribute = actor.getAttributeJson();
      let heroInfo = {
        actorId: dicHero.heroId,
        actorName: dicHero.name,
        attribute, lv,
        ce
      };

      let defense = await PvpDefenseModel.findByRoleId(roleId);
      if(!defense) {
        defense = await PvpDefenseModel.createPvpDefense({roleId, roleName, heroes: [heroInfo], ce});
      } else {
        defense = await PvpDefenseModel.addHeroToDefense(roleId, heroInfo, ce);
      }
      return ctx.service.utils.resResult(STATUS.SUCCESS, {
          defense
      });
  }


  public async removeHeroFromDefense(roleId: string, hid: number) {
      const {ctx} = this;

      let defense = await PvpDefenseModel.findByRoleId(roleId);
      if(!defense) {
            return ctx.service.utils.resResult(STATUS.GM_PVP_DEFENSE_NOT_FOUND);
        } 
        let {heroes} = defense;
        let curHero = heroes.find(cur => cur.actorId == hid);
        if(!curHero) {
            return ctx.service.utils.resResult(STATUS.GM_PVP_DEFENSE_HERO_NOT_FOUND);
        }
        defense = await PvpDefenseModel.removeHeroFromDefense(roleId, hid, curHero.ce);

      return ctx.service.utils.resResult(STATUS.SUCCESS, {
          defense
      });
  }
}