/********** 37sdk **********/

import { RoleModel, RoleType } from "../db/Role";
import { Chat37Params, CheckGuild37Params, CheckName37Params } from "../domain/sdk";
import { sendMailByContent, sendMailToGuildByContent } from './mailService';
import { getGoldObject } from '../pubUtils/itemUtils';
import { NAMEPLATE } from '../pubUtils/dicParam';
import { CHANNEL_PREFIX, getSdkChannelId, MAIL_TYPE, REDIS_KEY, SDK_37_ADDR, SDK_37_CONST, SDK_TA_CONST, THINKING_DATA_MODE, THINKING_DATA_MODE_LIST } from "../consts";
import { UserModel } from "../db/User";
import { request37CheckChat, request37Post } from "../pubUtils/httpUtil";
import { GuildModel } from "../db/Guild";
import { getRoleOnlineInfo, updateUserInfo } from "./redisService";
import { Application, pinus } from "pinus";
import { getGuildChannelSid } from "./chatService";
const ThinkingAnalytics = require("thinkingdata-node");

// 检查私聊是否合法

export async function checkPrivateChat(roleId: string, targetRoleId: string, message: string) {
    let body = new Chat37Params(message, getSdkChannelId('private'));
    let myRole = await RoleModel.findByRoleId(roleId);
    let myUser = await UserModel.findUserByUid(myRole.userInfo.uid);
    if(myUser.channelType == '37') {
        body.setByMyRole(myRole, myUser);
        let targetRole = await RoleModel.findByRoleId(targetRoleId);
        let targetUser = await UserModel.findUserByUid(targetRole.userInfo.uid);
        body.setByTargetRole(targetRole, targetUser);
        return await request37CheckChat(SDK_37_ADDR.CHECK_CHAT, body, SDK_37_CONST.CHAT_KEY);
    }
    return true;
}

export async function checkGuildChat(roleId: string, guildCode: string, message: string) {
    let body = new Chat37Params(message, getSdkChannelId(CHANNEL_PREFIX.GUILD));
    let myRole = await RoleModel.findByRoleId(roleId);
    let myUser = await UserModel.findUserByUid(myRole.userInfo.uid);
    if(myUser.channelType == '37') {
        body.setByMyRole(myRole, myUser);
        body.setByGuild(guildCode);
        return await request37CheckChat(SDK_37_ADDR.CHECK_CHAT, body, SDK_37_CONST.CHAT_KEY);
    }
    return true;
}

export async function checkOtherChat(roleId: string, channelPrefix: string, message: string) {
    let body = new Chat37Params(message, getSdkChannelId(channelPrefix));
    let myRole = await RoleModel.findByRoleId(roleId);
    let myUser = await UserModel.findUserByUid(myRole.userInfo.uid);
    if(myUser.channelType == '37') {
        body.setByMyRole(myRole, myUser);
        return await request37CheckChat(SDK_37_ADDR.CHECK_CHAT, body, SDK_37_CONST.CHAT_KEY);
    }
    return true;
}

export async function checkRoleName(roleId: string, roleName: string, myRole?: RoleType) {
    if(!myRole) {
        myRole = await RoleModel.findByRoleId(roleId);
    }
    let myUser = await UserModel.findUserByUid(myRole.userInfo.uid);
    let body = new CheckName37Params(myRole, roleName, myUser);
    if(myUser.channelType == '37') {
        return await request37Post(SDK_37_ADDR.CHECK_NAME, body, SDK_37_CONST.CHAT_KEY);
    }
    return true;
}

export async function checkGuildName(guildCode: string, serverId: number, name: string, notice: string) {
    let nameResult = true, noticeResult = true;
    if(name != undefined) {
        let body = new CheckGuild37Params(guildCode, serverId, 1, name);
        nameResult = await request37Post(SDK_37_ADDR.CHECK_UNION, body, SDK_37_CONST.CHAT_KEY);
    }
    if(notice) {
        let body = new CheckGuild37Params(guildCode, serverId, 2, notice);
        noticeResult = await request37Post(SDK_37_ADDR.CHECK_UNION, body, SDK_37_CONST.CHAT_KEY);
    }
    return nameResult && noticeResult
}


// 根据37sdk处理违规玩家名
export async function treatRoleName(roleId: string) {
    let role = await RoleModel.findByRoleId(roleId);
    if(role && role.sdkMark) { // 有设置标记的情况下
        let newName = "默认玩家名";
        // 新名字上传
        await checkRoleName(roleId, newName, role);
        // 改名字
        await RoleModel.updateRoleInfo(roleId, { roleName: newName, sdkMark: false });
        // 通知处理
        await updateUserInfo(REDIS_KEY.USER_INFO, roleId, [{ field: 'roleName', value: newName }]); // redis缓存
        const { sid } = await getRoleOnlineInfo(roleId);
        if(!!sid) {
            await pinus.app.rpc.connector.connectorRemote.setOtherUserRoleNameSession.toServer(sid,[{ roleId, roleName: newName }]); // 改session
        }
        // 补偿
        let gold = getGoldObject(NAMEPLATE.NAMEPLATE_FEECOST)
        await sendMailByContent(MAIL_TYPE.TREAT_ROLE_NAME, role.roleId, { goods: [gold] });
    }
}

// 根据37sdk处理违规军团数据
export async function treatGuildName(content: string) {
    let params: { code: string, serverId: number, type: number };
    try {
        params = JSON.parse(content);
    } catch(e) {
        return false;
    }

    let guild = await GuildModel.findByCode(params.code, params.serverId);
    if(guild && guild.sdkMark) { // 有设置标记的情况下
        if(params.type == 1) { // 公会名
            let newName = "默认公会名";
            // 新名字上传
            await checkGuildName(params.code, params.serverId, newName, undefined);
            await GuildModel.updateInfo(params.code, { name: newName, sdkMark: false });
            // 通知处理
            await sendMailToGuildByContent(MAIL_TYPE.TREAT_GUILD_INFO, params.code, {}); // 邮件
            let chatSid = await getGuildChannelSid(params.code);
            pinus.app.rpc.chat.guildRemote.updateInfo.toServer(chatSid, params.code, { name: newName }); // 军团推送
            await updateUserInfo(REDIS_KEY.GUILD_INFO, params.code, [{ field: 'name', value: newName }]); // redis缓存信息

        } else if (params.type == 2) { // 公会公告
            await checkGuildName(params.code, params.serverId, undefined, '');
            await GuildModel.updateInfo(params.code, { notice: '', sdkMark: false });
            // 通知处理
            await sendMailToGuildByContent(MAIL_TYPE.TREAT_GUILD_INFO, params.code, {}); // 邮件
            let chatSid = await getGuildChannelSid(params.code);
            pinus.app.rpc.chat.guildRemote.updateInfo.toServer(chatSid, params.code, { notice: '' }); // 军团推送
        }
    }
}

export function connectThinkingData(app: Application) {
    let ta;
    if(THINKING_DATA_MODE == THINKING_DATA_MODE_LIST.DEBUG) {
        ta = ThinkingAnalytics.initWithDebugMode(SDK_TA_CONST.APPID, SDK_TA_CONST.SERVER_URL);
    } else if (THINKING_DATA_MODE == THINKING_DATA_MODE_LIST.BATCH) {
        ta = ThinkingAnalytics.initWithBatchMode(SDK_TA_CONST.APPID, SDK_TA_CONST.SERVER_URL);
    } else if (THINKING_DATA_MODE == THINKING_DATA_MODE_LIST.LOGGING) {
        ta = ThinkingAnalytics.initWithLoggingMode(SDK_TA_CONST.LOG_PATH, {
            pm2: true
        });
    }
    ta.setDynamicSuperProperties(() => {
        return {
            env: app.get('env'),
            server: app.getServerId()
        };
      });
    app.set('ta', ta);
}

export function reportTAEvent(userCode: string,  serverId: number, eventName: string, ip: string) {
    console.log(userCode, serverId)
    let ta = pinus.app.get('ta');
    let event = {
        // 账号 ID （可选)
        accountId: `${userCode}`,
        // 访客 ID （可选)，账号 ID 和访客 ID 不可以都为空
        distinctId: "",
        // 事件名称 （必填)
        event: eventName,
        // 事件时间 (可选) 如果不填，将以调用接口时的时间作为事件时间
        time: new Date(),
        // 事件 IP (可选) 当传入 IP 地址时，后台可以解析所在地
        ip: ip,
        // 事件属性 (可选)
        properties: {
            serverId
        },
        callback(err) {
            console.log('*****测试接入事件', err)
        }

    };
    ta.track(event);
}