import { Application, BackendSession, ChannelService } from "pinus";
import { resResult, getRandEelm, getResStr, shouldRefresh, getRefTime, sortArrRandom } from "../../../pubUtils/util";
import { STATUS, ROLE_SELECT, FRIEND_DROP_TYPE, FRIEND_RELATION_TYPE, POPULATE_TYPE, BLOCK_OPEATE, CONSUME_TYPE, ITID, HERO_SELECT, EQUIP_SELECT, REDIS_KEY, MSG_SOURCE, MSG_TYPE } from "../../../consts";
import { RoleModel, RoleType } from "../../../db/Role";
import { getBeforeHourSeconds } from "../../../pubUtils/timeUtil";
import { FriendApplyModel } from "../../../db/FriendApply";
import { FriendApplyParams, FriendListParam, FriendRecommendParams, BlackListParam, FriendValueListParam } from "../../../domain/roleField/friend";
import { FriendShipModel, FriendShipType } from "../../../db/FriendShip";
import { FriendRelationModel, Relation } from "../../../db/FriendRelation";
import { isRoleOnline, getServerName, getRoleOnlineInfo } from "../../../services/redisService";
import { increaseFrdCnt, getRecommendType, sortByBeSentHeart } from "../../../services/friendService";
import { FriendPointModel } from "../../../db/FriendPoint";
import { gameData } from "../../../pubUtils/data";
import { addItems, handleCost } from "../../../services/rewardService";
import { getFriendPointObject } from "../../../pubUtils/itemUtils";
import { RewardInter } from "../../../pubUtils/interface";
import { FriendPresentLogModel } from '../../../db/FriendPresentLog';
import { HeroModel } from "../../../db/Hero";
import { EquipModel } from "../../../db/Equip";
import { getPlayerMainAttribute } from "../../../services/pvpService";
import { FRIEND } from "../../../pubUtils/dicParam";
import { PlayerDetail, PlayerDetailHero } from "../../../domain/battleField/guild";
import { createPrivateMsg, pushMsgToRole, pushPresent } from "../../../services/chatService";
import { Rank } from "../../../services/rankService";


export default function (app: Application) {
    return new FriendHandler(app);
}

export class FriendHandler {
    channelService: ChannelService;

    constructor(private app: Application) {
        this.channelService = this.app.get('channelService');
    }

    // 获取推荐好友列表
    public async getRecommend(msg: { }, session: BackendSession) {
        let roleId: string = session.get('roleId');
        
        const day = getBeforeHourSeconds(FRIEND.FRIEND_RECONMMEND_ACTIVETIME);

        const { lv, serverId: myServerId, userInfo: { serverType: myServerType } } = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_MY_SERVER); 
        let allList = await RoleModel.getRecommedList(lv - FRIEND.FRIEND_RECONMMEND_LEVEL, lv + FRIEND.FRIEND_RECONMMEND_LEVEL, day);

        // 筛掉自己今天申请过的人
        let applyList = await FriendApplyModel.getSentApplyList(roleId, getRefTime(new Date(), 0));
        allList = allList.filter(cur => {
            return !applyList.find(ccur => ccur.roleId == cur.roleId);
        });

        let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);

        let myServerList = new Array<FriendRecommendParams>();
        let otherServerList = new Array<FriendRecommendParams>();
        for(let role of allList) {
            let type = getRecommendType(myFriendRelation, roleId, role.roleId);
            if(type == FRIEND_RELATION_TYPE.NORMAL) {
                let param = new FriendRecommendParams(role);
                param.setType(type);

                let { serverId, userInfo: { serverType }} = role;
                let serverName = await getServerName(serverType, serverId);
                param.setServerName(serverId, serverName);

                if(myServerId == serverId && myServerType == serverType ) {
                    myServerList.push(param);
                } else {
                    otherServerList.push(param);
                }

            }
        }

        // 前4个是本服的，后4个随意，优先本服，其他补上
        let myServerLen = myServerList.length > FRIEND.FRIEND_RECONMMEND_SERVICE? FRIEND.FRIEND_RECONMMEND_SERVICE: myServerList.length;
        let list1:FriendRecommendParams[] = getRandEelm(myServerList, myServerLen);

        let otherServerLen = otherServerList.length > FRIEND.FRIEND_RECONMMEND_NUM - myServerLen? FRIEND.FRIEND_RECONMMEND_NUM - myServerLen: otherServerList.length;
        let list2:FriendRecommendParams[] = getRandEelm(otherServerList, otherServerLen);

        if(list2.length < FRIEND.FRIEND_RECONMMEND_NUM - myServerLen) {
            if(myServerList.length <= FRIEND.FRIEND_RECONMMEND_NUM - list2.length) {
                list1 = myServerList;
            } else {
                list1 = getRandEelm(myServerList, FRIEND.FRIEND_RECONMMEND_NUM - list2.length);
            }
        }
        list1 = sortArrRandom(list1);
        list2 = sortArrRandom(list2);
        
        let list = list1.concat(list2);

        return resResult(STATUS.SUCCESS, { list });
    }

    // 搜索好友
    public async searchUser(msg: { value: string }, session: BackendSession) {
        let roleId: string = session.get('roleId');
        
        let { value } = msg;
        let allList = await RoleModel.searchByNameOrId(value);
        let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);

        let list = new Array<FriendRecommendParams>();
        for(let role of allList) {
            let type = getRecommendType(myFriendRelation, roleId, role.roleId);
            let param = new FriendRecommendParams(role);
            param.setType(type);

            let { serverId, userInfo: { serverType }} = role;
            let serverName = await getServerName(serverType, serverId);
            param.setServerName(serverId, serverName);

            list.push(param);
        }

        return resResult(STATUS.SUCCESS, { list });
    }

    // 申请
    public async applyFriend(msg: { roleIds: string[] }, session: BackendSession) {
        
        let roleId: string = session.get('roleId');
        let roleIds = msg.roleIds;

        const role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_ROLE_ID); 
        let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);

        let str = '', resultRoleIds = new Array<string>();
        let uids = [];
        for(let hisRoleId of roleIds) {
            let type = getRecommendType(myFriendRelation, roleId, hisRoleId);
            if(type == FRIEND_RELATION_TYPE.HAS_FRIEND) {
                str = getResStr(STATUS.FRIEND_HAS_ADD); continue;
            } else if(type == FRIEND_RELATION_TYPE.HAS_BLOCKED) {
                str = getResStr(STATUS.FRIEND_HAS_BLOCKED); continue;
            } else if (type == FRIEND_RELATION_TYPE.MYSELF) {
                str = getResStr(STATUS.FRIEND_YOURSELF); continue;
            }

            let incResult = await RoleModel.increaseFriendApplyCnt(hisRoleId, 1, FRIEND.FRIEND_MANAGE_APPLICATION);
            if(!incResult) {
                str = getResStr(STATUS.FRIEND_HIS_APPLY_MAX); continue;
            }

            await FriendApplyModel.createApply(hisRoleId, role);
            resultRoleIds.push(hisRoleId);
            let hisOnlineInfo = await getRoleOnlineInfo(hisRoleId);
            if(hisOnlineInfo.isOnline) {
                uids.push({ uid: hisRoleId, sid: hisOnlineInfo.sid });
            }
        }

        this.channelService.pushMessageByUids('onFriendApply', resResult(STATUS.SUCCESS, { roleId }), uids);

        return resResult(STATUS.SUCCESS, {
            isSuccess: str == '',
            msg: str,
            roleIds: resultRoleIds
        });
    }
    
    // 获取申请列表
    public async getApplyList(msg: { }, session: BackendSession) {

        let roleId: string = session.get('roleId');

        let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);
        let list = await FriendApplyModel.getApplyList(roleId);
        let result = new Array<FriendApplyParams>();
        let delApplyCodeList = new Array<string>();
        for(let apply of list) {
            let friend = <RoleType>apply.friend;
            let type = getRecommendType(myFriendRelation, roleId, friend.roleId);

            let param = new FriendApplyParams(apply.applyCode, friend);

            let { serverId, userInfo: { serverType }} = friend;
            let serverName = await getServerName(serverType, serverId);
            param.setServerName(serverId, serverName);

            param.setType(type);
            if(type != FRIEND_RELATION_TYPE.NORMAL) {
                delApplyCodeList.push(apply.applyCode);
                continue;
            }

            result.push(param);
        }
        await FriendApplyModel.deleteApply(delApplyCodeList);
        await RoleModel.increaseFriendApplyCnt(roleId, -1 * delApplyCodeList.length, 50);

        return resResult(STATUS.SUCCESS, {
            list: result
        });
    }

    // （一键）同意/拒绝申请
    public async handleApply(msg: { applyCodeList: string[], isPass: boolean }, session: BackendSession) {
        let roleId: string = session.get('roleId');

        let { applyCodeList, isPass } = msg;

        let role = await RoleModel.findByRoleId(roleId);
        let friendCnt = role.friendCnt;

        let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);

        let applyList = await FriendApplyModel.getApplyListByCode(applyCodeList);
        let list = new Array<FriendListParam>();

        let str = '', resultApplyCodeList = new Array<string>();
        if(isPass) {
            for(let apply of applyList) {
                let type = getRecommendType(myFriendRelation, roleId, apply.frdRoleId);
                if(type == FRIEND_RELATION_TYPE.HAS_FRIEND) {
                    str = getResStr(STATUS.FRIEND_HAS_ADD);
                    resultApplyCodeList.push(apply.applyCode); continue;
                } else if(type == FRIEND_RELATION_TYPE.HAS_BLOCKED) {
                    resultApplyCodeList.push(apply.applyCode);
                    str = getResStr(STATUS.FRIEND_HAS_BLOCKED); continue;
                } else if (type == FRIEND_RELATION_TYPE.MYSELF) {
                    resultApplyCodeList.push(apply.applyCode);
                    str = getResStr(STATUS.FRIEND_YOURSELF); continue;
                }
                
                // 好友数量校验
                let friend = <RoleType>apply.friend;
                str = await increaseFrdCnt(role, friend, friendCnt);
                if(str != '') continue;

                // 创建friendShip
                let friendShip = await FriendShipModel.createFriendShip([roleId, friend.roleId]);
                if(!friendShip) {
                    str = getResStr(STATUS.FRIEND_SHIP_CREATE_ERROR); continue;
                }

                await FriendRelationModel.addFriend(roleId, friend, friendShip);
                await FriendRelationModel.addFriend(friend.roleId, role, friendShip);

                let param = new FriendListParam(friend, roleId, friendShip);
                let isOnline = await isRoleOnline(friend.roleId);
                param.setOnline(isOnline);

                let { serverId, userInfo: { serverType }} = friend;
                let serverName = await getServerName(serverType, serverId);
                param.setServerName(serverId, serverName);

                param.setType(FRIEND_RELATION_TYPE.HAS_FRIEND);
                list.push(param);
                resultApplyCodeList.push(apply.applyCode);
            }
        } else {
            resultApplyCodeList = applyCodeList;
        }

        await FriendApplyModel.deleteApply(resultApplyCodeList);
        await RoleModel.increaseFriendApplyCnt(roleId, -1 * resultApplyCodeList.length, 50);

        // 特殊处理：如果他点一键同意，有很多人，这个单独的人就不做这个额外的提示，直接把他好友申请删掉就好
        if(str == getResStr(STATUS.FRIEND_HAS_ADD) && resultApplyCodeList.length > 1) str = '';

        return resResult(STATUS.SUCCESS, {
            isSuccess: str == '',
            msg: str,
            applyCodeList: resultApplyCodeList,
            list,
            friendCnt
        });
    }

    // 获取好友列表
    public async getFriendList(msg: { }, session: BackendSession) {
        let roleId: string = session.get('roleId');

        let role = await RoleModel.findByRoleId(roleId);
        let list = new Array<FriendListParam>();
        let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND);
        let friendList = myRelation?myRelation.friends: [];

        for(let friend of friendList) {
            let friendRole = <RoleType>friend.role;
            let friendShip = <FriendShipType>friend.friendShip;
            if(!friendRole || !friendShip) continue;

            let fs = <FriendShipType>friend.friendShip;
            let ref = shouldRefresh(fs.refTime, new Date(), 0);
            if(ref) {
                friendShip = await FriendShipModel.refreshSendAndReceive(roleId, friendRole.roleId);
            }

            let param = new FriendListParam(friendRole, roleId, friendShip);
            let { serverId, userInfo: { serverType }} = friendRole;
            let serverName = await getServerName(serverType, serverId);
            param.setServerName(serverId, serverName);

            let isOnline = await isRoleOnline(friendRole.roleId);
            param.setOnline(isOnline);

            param.setType(FRIEND_RELATION_TYPE.HAS_FRIEND);
            
            list.push(param);
        }

        list.sort((a, b) => {
            if(a.isOnline != b.isOnline) {
                return a.isOnline?1:-1
            }
            if(a.quitTime != b.quitTime) {
                return b.quitTime - a.quitTime
            }
            return a.friendValue - b.friendValue;
        });

        let { friendCnt = 0, blockCnt = 0 } = role;
        let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleId, FRIEND_DROP_TYPE.SEND_GIFT);
        let { cnt: todayReceiveCnt = 0, sendCnt: todaySendCnt = 0 } = frdPointRec||{};

        return resResult(STATUS.SUCCESS, {
            todayReceiveCnt,
            todaySendCnt,
            list,
            friendCnt, blockCnt
        });
    }

    // 获取黑名单
    public async getBlackList(msg: { }, session: BackendSession) {
        let roleId: string = session.get('roleId');

        let role = await RoleModel.findByRoleId(roleId);
        let list = new Array<BlackListParam>();
        let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.BLACKLIST);
        let blacklist = myRelation?myRelation.blacklist: [];
        for(let bl of blacklist) {
            let friendRole = <RoleType>bl.role;
            if(!friendRole) continue;
            let param = new BlackListParam(friendRole);
            let isOnline = await isRoleOnline(friendRole.roleId);
            param.setOnline(isOnline);

            let { serverId, userInfo: { serverType }} = friendRole;
            let serverName = await getServerName(serverType, serverId);
            param.setServerName(serverId, serverName);

            param.setType(FRIEND_RELATION_TYPE.HAS_BLOCKED);
            
            list.push(param);

        }

        let { friendCnt = 0, blockCnt = 0 } = role;

        return resResult(STATUS.SUCCESS, {
            list,
            friendCnt, blockCnt
        });
    }


    // 拉黑/移除
    public async setBlackList(msg: { roleId: string, type: number }, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let { roleId: hisRoleId, type } = msg;

        let role = await RoleModel.findByRoleId(roleId);

        let str = '', list = new Array<BlackListParam>(), frdRoleIds = new Array<string>(), blackRoleIds = new Array<string>();
        if(type == BLOCK_OPEATE.ADD) { // 拉黑
            let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND);
            let friends = myRelation?myRelation.friends: [];
            let blacklist = myRelation?myRelation.blacklist: [];
            let curFriend = friends.find(cur => cur.roleId == hisRoleId);
            let curBlack = blacklist.find(cur => cur.roleId == hisRoleId);
            if(curBlack) {
                return resResult(STATUS.FRIEND_BLACK_HAS_ADD);
            }

            role = await RoleModel.increaseBlockCnt(roleId, 1, curFriend? -1: 0, FRIEND.FRIEND_BLACKLIST_MAX); // 增加黑名单人数
            if(!role) {
                return resResult(STATUS.FRIEND_BLACK_MAX)
            }
            await RoleModel.increaseFriendCnt(hisRoleId, curFriend? -1: 0); // 对方好友减少

            let friend: RoleType, friendShip: FriendShipType;
            if(!!curFriend) {
                await FriendShipModel.clearValue([roleId, hisRoleId]);
                friend = <RoleType>curFriend.role;
                friendShip = <FriendShipType>curFriend.friendShip;
            } else {
                friend = await RoleModel.findByRoleId(hisRoleId);
            }

            await FriendRelationModel.moveFromFriend(hisRoleId, role, friendShip, false, !!curFriend); //从对方好友删除
            await FriendRelationModel.moveFromFriend(roleId, friend, friendShip, true, !!curFriend); // 删除好友关系并拉黑
            await FriendApplyModel.deleteApplyByRoles(roleId, hisRoleId); // 删除双方的申请
            await RoleModel.increaseFriendApplyCnt(roleId, -1, 50);

            let param = new BlackListParam(friend);
            let isOnline = await isRoleOnline(friend.roleId);
            param.setOnline(isOnline);

            let { serverId, userInfo: { serverType }} = friend;
            let serverName = await getServerName(serverType, serverId);
            param.setServerName(serverId, serverName);

            param.setType(FRIEND_RELATION_TYPE.HAS_BLOCKED);
            list.push(param);
            frdRoleIds.push(roleId);
        } else if (type == BLOCK_OPEATE.REMOVE_FRIEND) { // 仅移除

            let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND);
            let friends = myRelation?myRelation.friends: [];
            let curFriend = friends.find(cur => cur.roleId == hisRoleId);
            if(!curFriend) {
                return resResult(STATUS.FRIEND_NOT_FOUND);
            }

            role = await RoleModel.increaseFriendCnt(roleId, -1); // 减少好友
            if(!role) {
                return resResult(STATUS.FRIEND_NOT_FOUND)
            }
            await RoleModel.increaseFriendCnt(hisRoleId, -1); // 对方好友减少

            let friend: RoleType, friendShip: FriendShipType;

            await FriendShipModel.clearValue([roleId, hisRoleId]);
            friend = <RoleType>curFriend.role;
            friendShip = <FriendShipType>curFriend.friendShip;

            await FriendRelationModel.moveFromFriend(hisRoleId, role, friendShip, false, !!curFriend); //从对方好友删除
            await FriendRelationModel.moveFromFriend(roleId, friend, friendShip, false, !!curFriend); // 删除好友关系并拉黑

            frdRoleIds.push(roleId);

        } else if(type == BLOCK_OPEATE.REMOVE_BLACK || type == BLOCK_OPEATE.REMOVE_AND_APPLY){
            let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.BLACKLIST);
            let blacklist = myRelation?myRelation.blacklist: [];

            let curFriend = blacklist.find(cur => cur.roleId == hisRoleId);
            if(!curFriend) {
                return resResult(STATUS.FRIEND_BLACK_NOT_FOUND);
            }

            role = await RoleModel.increaseBlockCnt(roleId, -1, 0, 100); // 黑名单人数减            
            if(!role) {
                return resResult(STATUS.FRIEND_BLACK_MAX)
            }
            await FriendRelationModel.removeFromBlack(roleId, hisRoleId);

            if(type == BLOCK_OPEATE.REMOVE_AND_APPLY) {
                // 申请好友
                let applyResult = await RoleModel.increaseFriendApplyCnt(hisRoleId, 1, FRIEND.FRIEND_MANAGE_APPLICATION);
                if(!applyResult) {
                    str = getResStr(STATUS.FRIEND_HIS_APPLY_MAX); 
                } else {
                    await FriendApplyModel.createApply(hisRoleId, role);
                }
            }
            blackRoleIds.push(roleId);

        } else {
            return resResult(STATUS.WRONG_PARMS);
        }

        let { friendCnt = 0, blockCnt = 0 } = role;

        return resResult(STATUS.SUCCESS, {
            frdRoleIds, blackRoleIds,
            isSuccess: str == '',
            msg: str,
            list,
            friendCnt, blockCnt
        });
    }

    // 赠送爱心/一键赠送
    public async sendHeart(msg: { roleId: string }, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let roleName: string = session.get('roleName');

        let { roleId: hisRoleId } = msg;
        
        let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND); // 好友关系，只有friendship被populate了
        let friends = myRelation?myRelation.friends: [];
        let arr = new Array<Relation>();
        if(hisRoleId != '') {
            let cur = friends.find(cur => cur.roleId == hisRoleId);
            if(!cur) return resResult(STATUS.FRIEND_NOT_FOUND);

            arr.push(cur);
        } else {
            arr = friends;
        }
        let canSendList = await sortByBeSentHeart(roleId, arr);
    
        let {lv} = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_LV);
        let dicFriendLv = gameData.roleFriend.get(lv);
        if(!dicFriendLv) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        // 情谊值有上限，送到上限为止
        let max = dicFriendLv.sendMax;
        let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleId, FRIEND_DROP_TYPE.SEND_GIFT);
        let { sendCnt: todaySendCnt = 0 } = frdPointRec||{};

        let todaySendInc = 0;
        let list = new Array<FriendValueListParam>();

        let uids = [];
        for(let relation of canSendList) {

            if(todaySendCnt + FRIEND.FRIEND_FRIENDPOINT_ADD > max) break;
            let fs = <FriendShipType>relation.friendShip;
            let ref = shouldRefresh(fs.refTime, new Date(), 0);
            let sendHeartRec = await FriendShipModel.sendHeart(roleId, relation.roleId, 1, FRIEND.FRIEND_RECEIVE_SINGLE, ref);
            if(!sendHeartRec) continue;

            let param = new FriendValueListParam(relation.roleId, roleId, sendHeartRec);
            list.push(param);

            todaySendCnt += FRIEND.FRIEND_FRIENDPOINT_ADD;
            todaySendInc += FRIEND.FRIEND_FRIENDPOINT_ADD;

            let hisOnlineInfo = await getRoleOnlineInfo(relation.roleId);
            if(hisOnlineInfo.isOnline) {
                uids.push({ uid: relation.roleId, sid: hisOnlineInfo.sid });
            }
        }
        this.channelService.pushMessageByUids('onFriendSendHeart', resResult(STATUS.SUCCESS, {roleId}), uids);
        if(todaySendInc <= 0) return resResult(STATUS.FRIEND_HAS_SENT);

        // 更新情谊值
        frdPointRec = await FriendPointModel.updateSendCntToday(roleId, roleName, todaySendInc, max, FRIEND_DROP_TYPE.SEND_GIFT); 

        return resResult(STATUS.SUCCESS, {
            todaySendCnt, list
        })
    }


    // 领取爱心/一键领取
    public async receiveHeart(msg: { roleId: string }, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let roleName: string = session.get('roleName');
        let sid: string = session.get('sid');

        let { roleId: hisRoleId } = msg;
        
        let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND); // 好友关系，只有friendship被populate了
        let friends = myRelation?myRelation.friends: [];
        let arr = new Array<Relation>();
        if(hisRoleId != '') {
            let cur = friends.find(cur => cur.roleId == hisRoleId);
            if(!cur) return resResult(STATUS.FRIEND_NOT_FOUND);

            arr.push(cur);
        } else {
            arr = friends;
        }
        let canReceiveList = await sortByBeSentHeart(roleId, arr);

        let {lv} = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_LV);
        let dicFriendLv = gameData.roleFriend.get(lv);
        if(!dicFriendLv) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        // 情谊值有上限，到上限为止
        let max = dicFriendLv.receiveMax;
        let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleId, FRIEND_DROP_TYPE.SEND_GIFT);
        let { cnt: todayReceiveCnt = 0 } = frdPointRec||{};
        
        let todayReceiveInc = 0;
        let list = new Array<FriendValueListParam>();
        for(let relation of canReceiveList) {
            if(relation.beSentHeart > 0) {
                if(todayReceiveCnt + FRIEND.FRIEND_FRIENDPOINT_ADD > max) break;

                // 收取爱心
                let fs = <FriendShipType>relation.friendShip;
                let ref = shouldRefresh(fs.refTime, new Date(), 0);
                let receiveHeartRec = await FriendShipModel.receiveHeart(roleId, relation.roleId, 1, relation.beSentHeart, ref);
                if(!receiveHeartRec) continue;
    
                let param = new FriendValueListParam(relation.roleId, roleId, receiveHeartRec);
                list.push(param);
    
                todayReceiveCnt += FRIEND.FRIEND_FRIENDPOINT_ADD;
                todayReceiveInc += FRIEND.FRIEND_FRIENDPOINT_ADD;
            }
        }
        if(todayReceiveInc <= 0) return resResult(STATUS.FRIEND_HAS_RECEIVE);
        let fp = getFriendPointObject(todayReceiveCnt);
        let goods = await addItems(roleId, roleName, sid, [fp])

        frdPointRec = await FriendPointModel.updatePointToday(roleId, roleName, todayReceiveInc, max, FRIEND_DROP_TYPE.SEND_GIFT); 

        return resResult(STATUS.SUCCESS, {
            goods,
            todayReceiveCnt, list
        })
    }

    // 赠送礼物
    public async sendPresent(msg: { roleId: string, items: RewardInter[] }, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let roleName: string = session.get('roleName');
        let sid: string = session.get('sid');
        let serverId: string = session.get('serverId');

        let { roleId: hisRoleId, items } = msg;
        let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND_NAME_ONLY);
        let friends = myRelation?myRelation.friends: [];
        let curFriend = friends.find(cur => cur.roleId == hisRoleId);
        if(!curFriend) return resResult(STATUS.FRIEND_NOT_FOUND);

        let friendValueInc = 0;
        for(let {id, count} of items ) {
            let dicGood = gameData.goods.get(id);
            if(!dicGood) {
                return resResult(STATUS.DIC_DATA_NOT_FOUND);
            }

            let dicItid = ITID.get(dicGood.itid);
            if (dicItid.type == CONSUME_TYPE.FRIEND_FAVOUR) {
                friendValueInc += dicGood.value * count;
            } else {
                return resResult(STATUS.WRONG_PARMS); 
            }
        }

        let costResult = await handleCost(roleId, sid, items);
        if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);

        let result = await FriendShipModel.addFriendValue(roleId, hisRoleId, friendValueInc);
        if(!result) return resResult(STATUS.FRIEND_NOT_FOUND);

        // TODO 日志可以转到log服
        await FriendPresentLogModel.createRecord(roleId, hisRoleId, items);
        for(let {id, count} of items ) {
            const msgData = await createPrivateMsg(roleId, roleName, MSG_TYPE.RICH_TEXT, MSG_SOURCE.PRIVATE_SEND_GIFT, JSON.stringify({ id, count }), hisRoleId, null);
            await pushMsgToRole(msgData);
            let hisRole = <RoleType>curFriend.role;
            await pushPresent(roleId, roleName, serverId, hisRole.roleName, id);
        }

        return resResult(STATUS.SUCCESS, {
            roleId: hisRoleId,
            ...result
        });
    }

    async getPlayerDetail(msg: { roleId: string }, session: BackendSession) {

        // let roleId = session.get('roleId');
        let { roleId: oppoRoleId } = msg;
        
        let result: PlayerDetail;

        let dbHeroes = await HeroModel.findByRole(oppoRoleId);
        let role = await RoleModel.findByRoleId(oppoRoleId, null, true);
        let { topLineup, topLineupCe, towerLv, showLineup } = role;

        let heroes = new Array<PlayerDetailHero>();

        if(showLineup) { // 设置过展示阵容
            for(let hid of showLineup) {
                let curHero = dbHeroes.find(cur => cur.hid == hid);
                if(curHero) {
                    let { lv, star, colorStar, quality } = curHero;
                    heroes.push({
                        actorId: hid, lv, star, colorStar, quality,
                        score: 0
                    });
                }
            }
        } else {
            for(let { hid } of topLineup) {
                let curHero = dbHeroes.find(cur => cur.hid == hid);
                if(curHero) {
                    let { lv, star, colorStar, quality } = curHero;
                    heroes.push({
                        actorId: hid, lv, star, colorStar, quality,
                        score: 0
                    });
                }
            }
        }

        let r = new Rank(REDIS_KEY.PVP_RANK, {});
        let rank = await r.getMyRank({ roleId: oppoRoleId });//去redis中获取排名

        result = new PlayerDetail({...role, defCe: topLineupCe, heroes});
        result.setWarStar(role.warStar, rank, towerLv);
        
        return resResult(STATUS.SUCCESS, result);
    }

    // 查看对象武将详细
    public async getHeroDetail(msg: { roleId: string, hids: number[] }, session: BackendSession) {
        // let roleId: string = session.get('roleId');
        // let sid: string = session.get('sid');

        let { roleId: hisRoleId, hids } = msg;

        let role = await RoleModel.findByRoleId(hisRoleId, ROLE_SELECT.ATTR);
        if(!role) return resResult(STATUS.ROLE_NOT_FOUND);

        let heroList = await HeroModel.findByHidRange(hids, hisRoleId, HERO_SELECT.HERO_DETAIL, true);
        if(heroList.length <= 0) return resResult(STATUS.HERO_NOT_FIND);

        let list = new Array();
        for(let {roleId, roleName, hid, hName, ce, lv, star, colorStar, quality, job, skins, attr: heroAttrs} of heroList) {

            let curSkin = skins.find(cur => cur.enable);
            let equips = await EquipModel.findListByHidAndRole(hisRoleId, hid, EQUIP_SELECT.HERO_DETAIL);
    
            let attributes = getPlayerMainAttribute(heroAttrs, role.attr);

            list.push({
                roleId, roleName, hid, hName, ce, lv, star, colorStar, quality, job,
                skin: curSkin?curSkin.id: 0, equips, attributes
            });

        }


        return resResult(STATUS.SUCCESS, { list });
    }

}