import { EErrorCode } from "../Config/_error_";
import * as _ from "underscore"
import { core, GLog } from 'cgserver';
import { MongoUserModel, MongoUserService } from "cgserver";
import { ERoleGroup } from "cgserver";
import { MatchItemInfo, MatchModel } from "./MatchService";
import { GHallCfg } from "../../Platform/HallWebServer/Config/HallConfig";
export class FollowerItem
{
    id=0
    nickname=""
    logo=""
    create_time=0
    money=0
}
/**
 * 记录用户的参赛信息和情况
 */
export class UserMatchInfo
{
    //比赛实例id
    ins_id=""
    //报名时间
    signup_time=0
    //报名费用
    sigup:MatchItemInfo=null
    //名词
    rank=-1
    //获得的奖励
    reward:MatchItemInfo=null
}
export class TaskStatus
{
    //最近达成时间
    latest_time=0
    money=0
}
export class AddressItem
{
    name=""
    phone=""
    address=""
    create_time=-1
}
export class ExtUserModel extends MongoUserModel
{
    coin:number=0//默认0
    crystal:number = 0//砖石
    money=0//钱包
    ticket=0
    bank_pwd:string="123456"
    bank_coin:number=0
    idcard_no=""

    addresses:AddressItem[]=[]
    address_time=0
    sign_count=0
    sign_time=0

    matchinfos:{[ins_id:string]:UserMatchInfo}={}
    //ins_id
    focusmatches:string[]=[]
    followers:{[user_id:number]:{id:number,create_time:number,money:number}}={}

    taskstatus:{[name:string]:TaskStatus}={}
}
let UserUpdateModel=["nickname","ip","sex","logo"]

export let GExtUserSer:ExtUserService = null
export class ExtUserService extends MongoUserService<ExtUserModel>
{
    constructor()
    {
        super(ExtUserModel)
        GExtUserSer=this
    }
    static create()
    {
        if(GExtUserSer)
        {
            return
        }
        new ExtUserService()
    }
    protected async _createNewUser(account_id:number,nickname:string,sex:number,logo:string,group?:ERoleGroup)
    {
        let rm = await super._createNewUser(account_id,nickname,sex,logo,group)
        let ext_rm = new ExtUserModel()
        for(let k in ext_rm)
        {
            if(rm[k]==undefined)
            {
                rm[k]=ext_rm[k]
            }
        }
        return rm
    }
    /**
     * 报名的用户处理，这里不处理重复报名，重复报名又matchins自行处理
     * 报名信息只保留最新的一次
     * @param user_id 
     * @param ins_id 
     * @param mm 
     * @returns 
     */
    async onSignUp(user_id:number,ins_id:string,mm:MatchModel)
    {
        let rs = {umi:<UserMatchInfo>null,errcode:null}
        let model = {
            id:1,
            coin:1
        }
        model["matchinfos."+ins_id]=1
        let user:ExtUserModel = await this.get(model,{id:user_id})
        for(let i=0;i<mm.signup_cost.length;++i)
        {
            let item = mm.signup_cost[i]
            //-99金币
            if(item.id==-99)
            {
                if(user.coin>=item.count)
                {
                    let umi = new UserMatchInfo()
                    umi.ins_id=ins_id
                    umi.signup_time=Date.now()
                    umi.sigup=item
                    umi.rank=-1
                    //todo 日志
                    let updatemodel =
                    {
                        "$set":{},
                        "$inc":
                        {
                            coin:-item.count,
                            "taskstatus.daymatch.money":GHallCfg.task.daymatch.count
                        },
                        
                    }
                    let daymatch=false
                    if(user.taskstatus?.daymatch?.latest_time)
                    {
                         let st = core.getStartTime(user.taskstatus.daymatch.latest_time)
                         let tst = core.getTodayStartTime()
                         if(st==tst)
                         {
                            daymatch=true
                         }
                    }
                    if(!daymatch)
                    {
                        updatemodel.$set={"taskstatus.daymatch.latest_time":umi.signup_time}
                    }
                    updatemodel.$set["matchinfos."+ins_id]=umi
                    let mg_rs = await GExtUserSer.updateOne(updatemodel,{_id:user._id})
                    if(mg_rs.errcode)
                    {
                        rs.errcode=mg_rs.errcode
                    }
                    else
                    {
                        rs.umi=umi
                    }
                    return rs
                }
            }
        }
        rs.errcode=EErrorCode.Cannot_Singup
        return rs
    }
    async onBind(user:ExtUserModel,pre_user_id:number)
    {
        let rs={errcode:null,user:<ExtUserModel>null,pre_user:<ExtUserModel>null}
        if(user.pre_user_id>0)
        {
            rs.errcode=EErrorCode.Was_Binded
            return rs
        }
        if(pre_user_id==user.id)
        {
            rs.errcode=EErrorCode.Proxy_Not_Bind_Self
            return rs
        }
        let pre_user = await GExtUserSer.getById(pre_user_id)
        if(!pre_user)
        {
            rs.errcode=EErrorCode.Proxy_Code_Not_Exist
            return rs
        }
        let mg_rs = await GExtUserSer.updateOne({
            "$set":{pre_user_id:pre_user_id,"taskstatus.bind.latest_time":Date.now()},
            "$inc":{"taskstatus.bind.money":GHallCfg.task.bind.count}
        },{id:user.id})
        if(mg_rs.errcode||mg_rs.rs.modifiedCount<=0)
        {
            rs.errcode=mg_rs.errcode||{id:10086,des:"绑定失败!"}
            return rs
        }
        user.pre_user_id=pre_user_id
        let model = {
            "$set":{"taskstatus.bebinded.latest_time":Date.now()},
            "$inc":{"taskstatus.bebinded.money":GHallCfg.task.bebinded.count}
        }
        //todo 金币日志
        model["$set"]["followers."+user.id]={id:user.id,create_time:Date.now(),money:0}
        await GExtUserSer.updateOne(model,{id:pre_user_id})
        rs.pre_user=pre_user
        rs.user=await GExtUserSer.getById(user.id)
        return rs
    }
    async getFollwers(user_id:number)
    {
        let rs=await this.aggregate(<any>[
            {"$match":{id:user_id}},
            {"$project":{followers:1}},
            {
                "$addFields": {
                    "followers": {
                        "$objectToArray": "$followers"
                    }
                }
            },
            {
                "$lookup":
                {
                    from:"user",
                    localField:"followers.v.id",
                    foreignField:"id",
                    as:"user_followers"
                }
            },
            {"$project":{_id:1,followers:1,"user_followers.id":1,"user_followers.nickname":1,"user_followers.logo":1}}
        ]).toArray()
        if(!rs||rs.length==0)
        {
            return null
        }
        let data=rs[0]
        data.followers=data.followers||[]
        data.user_followers=data.user_followers||[]
        let followers:FollowerItem[]=[]
        for(let i=0;i<data.followers.length;++i)
        {
            let one:{id:number,create_time:number,money:number} = data.followers[i].v
            let fi = new FollowerItem()
            fi.id=one.id
            fi.create_time=one.create_time
            fi.money=one.money
            for(let j=0;j<data.user_followers.length;++j)
            {
                let uf:{id:number,logo:string,nickname:string} = data.user_followers[j]
                if(uf.id==fi.id)
                {
                    fi.nickname=uf.nickname
                    fi.logo=uf.logo
                    break
                }
            }
            followers.push(fi)
        }
        return followers
    }
    async updateBankPwd(user_id,old_pwd,new_pwd)
    {
        if(!new_pwd)
        {
            return EErrorCode.Password_No_Empty
        }
        if(new_pwd.length<6)
        {
            return EErrorCode.Password_Len_Not_Correct
        }
        let user = await GExtUserSer.getById(user_id)
        if(!user)
        {
            return EErrorCode.No_User
        }
        if(user.bank_pwd!=old_pwd)
        {
            return EErrorCode.Password_Not_Correct
        }
        let sr = await this.updateOne({bank_pwd:new_pwd},{id:user_id})
        if(sr.errcode)
        {
            GLog.error(sr.errcode.des+"  user_id="+user_id)
            return EErrorCode.Mysql_Error
        }
    }
    async addAddress(user_id:number,address:AddressItem)
    {
        return await this.updateOne({"$push":{"addresses":address}},{"id":user_id})
    }
    async updateAddress(user_id:number,address:AddressItem)
    {
        return await this.updateOne({"$set":{"addresses.$":address}},{"id":user_id,"addresses.create_time":address.create_time})
    }
    async removeAddress(user_id:number,create_time:number)
    {
        return await this.updateOne({"$pull":{"addresses":{create_time:create_time}}},{"id":user_id})
    }
}
new ExtUserService()