import { GServerSer } from '../../../Common/Service/ServerService';
import * as _ from "underscore";
import { GExtAccountSer } from '../../../Common/Service/ExtAccountService';
import { GHttpTool, GLog, GMongoCacheSer, GWechatTool, MongoCacheModel } from 'cgserver';
import { GExtUserSer } from '../../../Common/Service/ExtUserService';
import { BaseHallController } from './BaseHallController';
import { GHallCfg } from '../Config/HallConfig';
import { EErrorCode } from '../Config/_error_';
import { GStatisticsLogin, StatisticsLoginModel } from '../../../Common/Service/StatisticsLogin';
import { GSessionSer, SessionModel } from '../../../Common/Service/SessionService';
import { EAccountFrom } from 'cgserver';
import { GRandomNameCfg } from '../../../Common/Config/RandomNameConfig';
import { GCacheTool } from 'cgserver';
import { core } from 'cgserver';
import { ns_common } from '../../../Common/Config/_ini_';

//先去掉其他的，只支持OpenSocial登陆
export class AuthController extends BaseHallController
{
    /**
     * {
     * 返回结果如下：
     * region 区域
     * server 服务器
     * [{region: [], server: []}, ...]
     * }
     * 接收请求获取服务器
     */
    async onGetAllServers()
    {
        let region_servers = await GServerSer.getAll()
        this.showJson({regions:region_servers})
    }
    async onThirdLogin()
    {
        let params = this._request.postData||{}
        if(params.wxcode)
        {
            this._onWechatLogin()
        }
        else
        {
            if(params.from==EAccountFrom.QuickPhone)
            {
                let code = await GMongoCacheSer.getData(params.unionid+"")
                if(code)
                {
                    GCacheTool.add("phone_code_"+params.unionid,code,365*24*60*60*1000)
                }
                else if(ns_common.GIsTest||ns_common.GNoCode)
                {
                    code = "123456"
                    GCacheTool.add("phone_code_"+params.unionid,code,365*24*60*60*1000)
                }
                params.openid=code
            }
            let pre_time=Date.now()
            let login_data = await GExtAccountSer.login(params.unionid+"",params.openid+"",this.remoteHost,params.from,params.access_token,params.extra)
            GLog.info("login_time:"+(Date.now()-pre_time).toLocaleString(),true)
            pre_time=Date.now()
            if(login_data.errcode)
            {
                this.showJson({errcode:login_data.errcode})
                return
            }
            let user = await GExtUserSer.getByAccountId(login_data.account.id)
            if(user.nickname=="noname")
            {
                user.nickname=GRandomNameCfg.getRandomName()
                GExtUserSer.updateOne({nickname:user.nickname},{id:user.id})
            }
            if(login_data.is_new&&GHallCfg.NewUserCoin>0)
            {
                GExtUserSer.updateOne({$inc:{coin:GHallCfg.NewUserCoin}},{id:user.id})
            }
            GLog.info("login_getuser:"+(Date.now()-pre_time).toLocaleString(),true)
            pre_time=Date.now()
            let s = await GServerSer.getRandomServerByName("hall")
            let hall = {host:s.host,port:s.port}
            s = await GServerSer.getRandomServerByName("texas")
            GLog.info("login_getserver:"+(Date.now()-pre_time).toLocaleString(),true)
            pre_time=Date.now()
            let slot = {host:s.host,port:s.port}
            let session:SessionModel = await GSessionSer.get(null,{user_id:user.id})
            if(session?.ingame)
            {
                slot.host=session.host
                slot.port=session.port
            }
            GLog.info("login_getsession:"+(Date.now()-pre_time).toLocaleString(),true)
            pre_time=Date.now()
            this.showJson({account:login_data.account,token:login_data.token,hall:hall,texas:slot})
            let slm = new StatisticsLoginModel()
            slm.account_id=login_data.account.id
            slm.login_ip=this.remoteHost
            slm.login_time=Date.now()
            GStatisticsLogin.insert(slm)
        }
    }
    async onGetPhoneCode()
    {
        let params = this.postData
        //"login","register","resetpassword"
        let why = this.postData.why
        let phone = params.phone+""
        let code = _.random(1234,9876)
        let msg = `【ZDPT】验证码${code}，用于注册/登录，10分钟内有效。验证码提供给他人可能导致账号被盗，请勿泄露，谨防被骗。`
        let errcode = await this._getPhoneCode(phone,msg)
        if(errcode)
        {
            this.showJson({errcode:errcode})
            return
        }
        let cm = new MongoCacheModel()
        cm.key=phone
        cm.data=code
        cm.expireAt=Date.now()+365*24*60*60*1000
        await GMongoCacheSer.updateOne(cm,{key:phone},true)
        this.showJson()
    }
    protected async _getPhoneCode(phone:string,msg:string)
    {
        if(!core.isPhoneNo(phone))
        {
            return EErrorCode.Wrong_Phone
        }
        let auth_code = "5b7c6f18e89eda908a9cde344eaecdad45984333"
        let spid = "100270"
        let auth_key = "594b316b7a0783751910622e96fbbe29"
        let extport = ""
        let smsid = ""
        let mobiles = phone
        let content = encodeURIComponent(msg)
        let sendtime = "";
        let timestamp = String(Date.now())
        let str = auth_code + spid + mobiles + sendtime + content + timestamp + auth_key
        let sign = core.sha1(str).toLowerCase()
        let res = await GHttpTool.httpPost("http://hp1.njsswx.com:9000/SMSController/sendSms.do", JSON.stringify({
            auth_code: auth_code,
            spid: spid,
            extport: extport,
            smsid: smsid,
            mobiles: mobiles,
            content: content,
            sendtime: sendtime,
            timestamp: timestamp,
            sign: sign
        }))
        if(res.body?.code!=1)
        {
            GLog.error(res.body)
            return EErrorCode.Get_Code_Failed
        }
    }
    async onCheckPhoneExist()
    {
        let phone = this.postData.phone+""
        let data = await GExtAccountSer.get({id:1},{phone:phone})
        if(data)
        {
            this.showJson({errcode:EErrorCode.Phone_Exist})
            return
        }
        this.showJson({})
    }
    async onCheckInviteExist()
    {
        let pre_user_id = this.postData.pre_user_id
        let data = await GExtUserSer.get({_id:1},{pre_user_id:pre_user_id})
        if(!data)
        {
            this.showJson({errcode:EErrorCode.No_Invite_Code})
            return
        }
        this.showJson({})
    }
    async onRegister()
    {
        let params = this.postData
        if(params.from==EAccountFrom.Phone)
        {
            let code = await GMongoCacheSer.getData(params.key+"")
            if(!code||code!=params.code)
            {
                if(ns_common.GIsTest||ns_common.GNoCode)
                {

                }
                else
                {
                    this.showJson({errcode:EErrorCode.Verify_Code_Failed})
                    return
                }
            }
        }
        let register_data = await GExtAccountSer.register(params.from,params.key+"",params.password+"",this.remoteHost,params.extra)
        if(register_data.errcode)
        {
            this.showJson({errcode:register_data.errcode})
            return
        }
        if(params.pre_user_id)
        {
            let pre_user = await GExtUserSer.getById(params.pre_user_id)
            if(pre_user)
            {
                await GExtUserSer.updateOne({pre_user_id:params.pre_user_id},{id:register_data.user.id})
            }
        }
        this.showJson()
    }
    async onResetPassword()
    {
        let params = this.postData
        if(!params.password||params.password.length<6)
        {
            this.showJson({errcode:EErrorCode.Password_Too_Short})
            return
        }
        if(params.from==EAccountFrom.Phone)
        {
            let code = await GMongoCacheSer.getData(params.key+"")
            if(!code||code!=params.code)
            {
                if(ns_common.GIsTest)
                {

                }
                else
                {
                    this.showJson({errcode:EErrorCode.Verify_Code_Failed})
                    return
                }
            }
        }
        let where = {}
        if(params.from==EAccountFrom.Phone)
        {
            where["phone"]=params.key+""
        }
        else
        {
            where["name"]=params.key+""
        }
        let res = await GExtAccountSer.updateOne({password:params.password+""},where)
        if(res.errcode)
        {
            this.showJson({errcode:res.errcode})
            return
        }
        if(res.rs.modifiedCount<=0)
        {
            this.showJson({errcode:EErrorCode.Handle_Failed})
            return
        }
        this.showJson({})
    }
    protected async _onWechatLogin()
    {
        let params = this.postData
        let code=params.wxcode

        let access_info = await GWechatTool.getAccessInfo(code)
        if(!access_info)
        {
            this.showJson({errcode:EErrorCode.Login_Failed})
            return
        }
        let login_data = await GExtAccountSer.login(access_info.unionid,access_info.openid,this.remoteHost,EAccountFrom.WeChat,access_info.access_token)
        if(login_data.errcode)
        {
            this.showJson({errcode:EErrorCode.Login_Failed})
            return
        }
        else
        {
            this.showJson({account:login_data.account,token:login_data.token})
            return
        }
    }
}