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 { Service } from 'egg';
import Counter from '@db/Counter';

/**
 * 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 {
            "status": "error",
            "data": "参数错误"
        }
    }

    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 {
        "status": "ok",
        "data": list
      }
    } else {
      return {
        "status": "error",
        "data": "未找到玩家"
      }
    }
  }

  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 { status: "ok", data: { roleId: role.roleId } };
    }
    return {
        "status": "error",
        "data": "创建失败"
    };
  }


  /**
   * 根据类型等搜索玩家
   */
  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 {
            "status": "error",
            "data": "参数错误"
        }
    }

    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 {
            "status": "ok",
            "data": result
        }
    } else {
      return {
        "status": "error",
        "data": "未找到玩家"
      }
    }
  }

  public async createHero(uids: Array<string>, hid: number, hlv: number) {
    const {ctx} = this;
    console.log('gm createHero', uids, hid, hlv);

    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;
            }

            const heroInfo = {
                roleId,
                roleName: role.roleName,
                hid: hid,
                hName: dicHero.name,
                seqId,
                lv: hlv
            }
            await HeroModel.createHero(heroInfo);
        } else {
            flag = 1, msg = '未找到角色' + roleId;
        }
    }

    if (flag) {
        return {
            "status": "error",
            "data": msg
        }
    } else {
        return {
            "status": "ok",
            "data": uids
        };
    }
  }

  public async createEquip(uids: Array<string>, eid: number, elv: number, ecount: number, ehid: number) {
    const {ctx} = this;
    console.log('gm createEquip');

    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 {
            "status": "error",
            "data": msg
        }
    } else {
        return {
            "status": "ok",
            "data": uids
        };
    }
  }

  public async createItem(uids: Array<string>, itemid: number, itemcount: number) {
    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 {
            "status": "error",
            "data": "创建失败"
        }
    } else {
        return {
            "status": "ok",
            "data": uids
        };
    }
  }
}