import { UserModel } from '@db/User';
import { RoleModel } from '@db/Role';
import { HeroModel } from '@db/Hero';
import { EquipModel } from '@db/Equip';
import { ItemModel } from '@db/Item';
import { CounterModel } from '@db/Counter';
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 { HeroSoulModel } from '@db/HeroSoul';
import { ScriptItemModel } from '@db/ScriptItem';
import { SearchRecordModel } from '@db/SearchRecord';
import { TowerRecordModel } from '@db/TowerRecord';
import { TowerTaskRecModel } from '@db/TowerTaskRec';

import { Service } from 'egg';
import Counter from '@db/Counter';
import { STATUS } from '@consts/statusCode';

/**
 * 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('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 HeroSoulModel.deleteAccount(roleId);
    await ItemModel.deleteAccount(roleId);
    await RoleModel.deleteAccount(roleId);
    await ScriptItemModel.deleteAccount(roleId);
    await SearchRecordModel.deleteAccount(roleId);
    await TowerTaskRecModel.deleteAccount(roleId);
    await TowerRecordModel.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 {roleId, roleName, serverId, lv, vLv} = role;
            let {uid, tel} = role.userInfo;
            result.push({
                key: roleId, roleId, roleName, serverId, lv, vLv, uid, tel, heroCount, equipCount, itemCount
            });
        }
        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 hid = parseInt(_hid);
    let hlv = parseInt(_hlv);
    if(isNaN(hid) || isNaN(hlv)) 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) {
            let hero = await HeroModel.findByHidAndRole(hid, roleId);
            if(hero) {
                flag = 1, msg = "角色" + roleId + "已拥有武将" + hid;
                break;
            }
            const seqId = await CounterModel.getNewCounter('hid')||-1;
            let dicHero = ctx.service.utils.getHeroById(hid);
            if(!dicHero) {
                flag = 1, msg = "未找到武将" + hid;
                break;
            }
            let ce = ctx.service.utils.calculateCE({hid: hid, lv: hlv});

            const heroInfo = {
                roleId,
                roleName: role.roleName,
                hid: hid,
                hName: dicHero.name,
                seqId,
                lv: hlv,
                ce
            }
            await HeroModel.createHero(heroInfo);
        } 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 createEquip(uids: Array<string>, _eid: string, _elv: string, _ecount: string, _ehid: string) {
    const {ctx} = this;
    console.log('gm createEquip', uids, _eid, _elv, _ecount, _ehid);
    let eid = parseInt(_eid);
    let elv = parseInt(_elv);
    let ecount = parseInt(_ecount);
    let ehid = parseInt(_ehid);
    if(isNaN(eid) || isNaN(elv) || 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 = ctx.service.utils.getGoodById(eid);
                if(!dicEquip) {
                    flag = 1, msg = "未找到装备" + eid;
                    break;
                }
                const seqId = await CounterModel.getNewCounter('eid')||-1;
                const equipInfo = {
                    roleId,
                    roleName: role.roleName,
                    eid,
                    eName: dicEquip.name,
                    seqId,
                    type: 1,
                    lv: elv
                }
                const equip = await EquipModel.createEquip(equipInfo);
                if(ehid > 0 && equip) {
                    await HeroModel.addEquip(roleId, ehid, equip._id);
                }
            }
        } 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);

    console.log('gm createEquip');

    let flag = 0;
    for(let roleId of uids) {
        let role = await RoleModel.findByRoleId(roleId);
        if(role) {
            let item = await ItemModel.findbyItemid(itemid, roleId);
            if(item) {
                await ItemModel.changeItemCount(item.seqId, itemcount);
            } else {
                const seqId = await CounterModel.getNewCounter('itemid')||-1;
                const itemInfo = {
                    roleId,
                    roleName: role.roleName,
                    itemid,
                    itemName: '包子',
                    seqId,
                    type: 1,
                    count: itemcount
                }
                await ItemModel.createItem(itemInfo);
            }
        } else {
            flag = 1;
        }
    }

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