import { GClubShieldSer } from './ClubShieldService';
import { EErrorCode } from '../Config/_error_';
import { GExtUserSer } from './ExtUserService';
import { GLog } from 'cgserver';
/*
    为了方便简单移植，，俱乐部模块就全部写在这里了，不按照功能分文件了虽然不规范，但是非常好用
*/
import * as _ from "underscore"
import { GCacheTool } from 'cgserver';
import { MongoBaseModel } from 'cgserver';
import { MongoBaseService } from 'cgserver';
import { GMongoCacheSer } from 'cgserver';

export class ClubModel extends MongoBaseModel
{
    id:number=-1 //俱乐部id
    title:string=""//俱乐部名称
    notice:string=""//俱乐部公告
    vip_level:number=-1//vip等级
    max_member:number=-1//成员上限
    max_admin:number=-1//管理员上限
    user_id:number=-1//俱乐部创建者
    coin:number=0
    crystal:number=0//俱乐部基金
    /**
     * 加入是否需要审核
     */
    need_review:number=1

    //高级设置
    allow_anyone_create:number=0//是否允许所有人开房
    club_for_create_fee:number=0//房费是否由俱乐部承担
    allow_anyone_charge:number=0//是否允许所有人充值俱乐部基金
    is_dismiss:number=0//时候已经解散

    create_time:number=-1
    exp_time:number=-1//过期时间
    users=new Array<UserClubModel>()
}

let ClubInfoUpdateModel=["title","notice","allow_anyone_create","club_for_create_fee","allow_anyone_charge"]

export class UserClubModel
{
    user_id:number=-1
    club_id:number=-1
    is_admin:number=0
    create_time:number = -1

    //俱乐部的成员信息
    exp:number = 0
    level:number = 1//等级
    vip_exp:number = 0
    vip_level:number = 0//等级

    coin:number=0//默认0
    crystal:number = 0//砖石
    bank_pwd:string="123456"
    bank_coin:number=0
}
export let GClubSer:ClubService=null
class ClubService extends MongoBaseService<ClubModel>
{
    async getNewId()
    {
        while(true)
        {
            let id = _.random(126345,999999)
            let club = await this.get(id)
            if(!club)
            {
                return id
            }
        }
    }
    async isInClub(user_id:number,club_id:number)
    {
        let userclub = await this.getUserClub(user_id,club_id)
        if(!userclub)
        {
            return false
        }
        return true
    }
    async isAdminInClub(user_id,club_id)
    {
        let userclub = await this.getUserClub(user_id,club_id)
        if(!userclub)
        {
            return false
        }
        return userclub.is_admin>0
    }
    async dismiss(user_id,club_id)
    {
        let club = await this.get(club_id)
        if(!club)
        {
            return EErrorCode.No_Club_By_Id
        }
        if(club.user_id!=user_id)
        {
            return EErrorCode.Not_Club_Creator
        }
        this.updateOne({is_dismiss:1},{id:club_id})
    }
    async removeMember(admin_user_id,remove_user_id,club_id)
    {
        if(!await this.isInClub(remove_user_id,club_id))
        {
            return EErrorCode.Not_In_Club
        }
        let sr = await this.updateOne({$pull:{"users.user_id":remove_user_id}},{id:club_id})
        return sr.errcode
    }
    async createClub(user_id:number,title:string)
    {
        let rs={club:<ClubModel>null,errcode:null}
        let exist_club = await this.get({id:1},{title:title})
        if(exist_club)
        {
            rs.errcode = EErrorCode.Club_Title_Exist
            return rs
        }
        let cm = new ClubModel()
        cm.id = await this.getNewId()
        cm.title = title
        cm.notice = "会长很懒，什么也没有留下！"
        cm.user_id = user_id
        cm.create_time=Date.now()
        await this.insert(cm)
        this._addMemeber(user_id,cm.id,2)
        rs.club = cm
        return rs
    }
    async addAdmin(club_id:number,user_id:number)
    {
        let sr = await this.updateOne({"users.is_admin":1},{"users.$.user_id":user_id,$ne:{"users.$.is_admin":2},id:club_id})
        if(sr.errcode||sr.rs.modifiedCount==0)
        {
            return false
        }
        return true
    }
    async removeAdmin(club_id:number,user_id:number)
    {
        let sr = await this.updateOne({"users.is_admin":0},{"users.$.user_id":user_id,id:club_id})
        if(sr.errcode||sr.rs.modifiedCount==0)
        {
            return false
        }
        return true
    }
    async updateInfo(user_id,club_id,jsonData)
    {
        let rs={club:<ClubModel>null,errcode:null}
        let club = await this.get({
            title:1,
            notice:1,
            allow_anyone_create:1,
            club_for_create_fee:1,
            allow_anyone_charge:1
        },{id:club_id})
        if(!club)
        {
            rs.errcode = EErrorCode.No_Club_By_Id
            return rs
        }
        if(club.user_id!=user_id)
        {
            rs.errcode = EErrorCode.Not_Club_Creator
            return rs
        }
        let model = _.pick(jsonData,ClubInfoUpdateModel)
        if(model.title&&model.title.length==0)
        {
            rs.errcode = EErrorCode.Club_Title_Not_Null
            return rs
        }
        if(model.allow_anyone_create!=undefined)
        {
            model.allow_anyone_create = model.allow_anyone_create||0
        }
        if(model.club_for_create_fee!=undefined)
        {
            model.club_for_create_fee = model.club_for_create_fee||0
        }
        if(model.allow_anyone_charge!=undefined)
        {
            model.allow_anyone_charge = model.allow_anyone_charge||0
        }
        let sr = await this.updateOne(model,{id:club_id})
        if(sr.errcode)
        {
            rs.errcode = EErrorCode.Mysql_Error
            return rs
        }
        rs.club = await this.get(null,{id:club_id})
        return rs
    }
    async applyJoin(user_id,club_id)
    {
        let rs={cm:<ClubModel>null,errcode:null}
        if(await GClubShieldSer.isShield(user_id,club_id))
        {
            rs.errcode = EErrorCode.Shield_By_Club
            return rs
        }
        rs.cm = await GClubSer.get(club_id)
        if(!rs.cm)
        {
            rs.errcode = EErrorCode.No_Club_By_Id
            return rs
        }
        if(rs.cm.need_review)
        {
            let rm = await GExtUserSer.getById(user_id)
            let cjm = 
            {
                user_id:rm.id,
                user_nickname:rm.nickname,
                user_logo:rm.logo,
                user_sex:rm.sex,
                club_id:club_id,
                club_name:rs.cm.title
            }
            let key="table_club_join_" + club_id
            GMongoCacheSer.updateOne({key:key,$push:{data:cjm}},{key:key},true)
        }
        else
        {
            let error = await this._addMemeber(user_id,club_id)
            if(error)
            {
                rs.errcode=error
            }
        }
        return rs
    }
    async getApplyList(user_id,club_id)
    {
        let rs={list:null,errcode:null}
        if(!await this.isAdminInClub(user_id,club_id))
        {
            rs.errcode = EErrorCode.Not_Club_Admin
            return rs
        }
        let one = await GMongoCacheSer.get(null,{key:"table_club_join_" + club_id})
        rs.list = one?.data
        return rs
    }
    async agreeJoin(agree_user_id,join_user_id,club_id,is_agree:boolean)
    {
        if(!await this.isAdminInClub(agree_user_id,club_id))
        {
            return EErrorCode.Not_Club_Admin
        }
        let key = "table_club_join_" + club_id
        let one = await GMongoCacheSer.get(null,{key:key,"data.$.user_id":join_user_id})
        if(!one||!one.data||one.data.length==0)//根本没有申请数据
        {
            return EErrorCode.No_Apply_Join_Club
        }
        GMongoCacheSer.updateOne({$pull:{"data.$.user_id":join_user_id}},{key:key})
        if(is_agree)
        {
            return await this._addMemeber(join_user_id,club_id)
        }
        return
    }
    protected async _addMemeber(user_id:number,club_id:number,is_admin?:number)
    {
        let uc = await this.getUserClub(user_id,club_id)
        if(uc)
        {
            return EErrorCode.Add_Member_Failed
        }
        is_admin = is_admin || 0

        let rcm = new UserClubModel()
        rcm.club_id = club_id
        rcm.is_admin = is_admin
        rcm.user_id = user_id
        rcm.create_time = new Date().getTime()
        let sr = await this.updateOne({$push:{users:rcm}},{id:club_id})
        if(sr.errcode)
        {
            return sr.errcode
        }
        if(sr.rs.matchedCount==0)
        {
            return EErrorCode.Add_Member_Failed
        }
        return
    }

    ///////////////////////////userclub相关
    /**
     * 数据有缓存可以随意调用
     * @param user_id 
     * @param club_id 
     */
    async getUserClub(user_id:number,club_id:number)
    {
        let key = "userclub_"+club_id+"_"+user_id
        let ucm:UserClubModel = GCacheTool.get(key)
        if(ucm)
        {
            return ucm
        }
        let one = await this.get({users:1},{id:club_id,"users.$.id":user_id})
        if(!one||!one.users||one.users.length==0)
        {
            return ucm
        }
        ucm = one.users[0]
        //保留一分钟即可
        GCacheTool.add(key,ucm,1*60*1000)
        return ucm
    }
    async updateBankPwd(user_id:number,club_id:number,old_pwd:string,new_pwd:string)
    {
        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({"users.bank_pwd":new_pwd},{id:club_id,"users.$.id":user_id})
        if(sr.errcode||sr.rs.modifiedCount==0)
        {
            GLog.error(sr.errcode?.des+"  user_id="+user_id)
            return EErrorCode.Mongo_Error
        }
        this.clearCacheData(user_id,club_id)
    }
    async addBankCoin(user_id:number,club_id:number,dtcoin:number)
    {
        if(!dtcoin)
        {
            return
        }
        let sr = await this.updateOne({$inc:{"users.bank_coin":dtcoin}},{id:club_id,"users.$.id":user_id})
        if(sr.errcode||sr.rs.modifiedCount==0)
        {
            GLog.error(sr.errcode?.des+"  user_id="+user_id)
            return EErrorCode.Mongo_Error
        }
        this.clearCacheData(user_id,club_id)
    }
    async addCoin(user_id:number,club_id:number,dtcoin:number)
    {
        if(!dtcoin)
        {
            return
        }
        let sr = await this.updateOne({$inc:{"users.coin":dtcoin}},{id:club_id,"users.$.id":user_id})
        if(sr.errcode||sr.rs.modifiedCount==0)
        {
            GLog.error(sr.errcode?.des+"  user_id="+user_id)
            return EErrorCode.Mongo_Error
        }
        this.clearCacheData(user_id,club_id)
    }
    async addCrystal(user_id:number,club_id:number,dtcrystal:number)
    {
        if(!dtcrystal)
        {
            return
        }
        let sr = await this.updateOne({$inc:{"users.crystal":dtcrystal}},{id:club_id,"users.$.id":user_id})
        if(sr.errcode||sr.rs.modifiedCount==0)
        {
            GLog.error(sr.errcode?.des+"  user_id="+user_id)
            return EErrorCode.Mongo_Error
        }
        this.clearCacheData(user_id,club_id)
    }
    clearCacheData(user_id:number,club_id:number)
    {
        let key = "userclub_"+club_id+"_"+user_id
        GCacheTool.remove(key)
    }
}
GClubSer = new ClubService("club",ClubModel)