import mongoose, {now, Promise, Schema} from "mongoose"
import { DBUser, DBUserInfo } from "../DBUserDef";
import { TokenUtils } from "../../common/TokenUtils";
import {dbDan, dbHero, dbItem} from "../DBMgr";
import {CfgAreanMgr} from "../../configs/ConfigDataManager";
import {EAreanBuyType} from "../../shared/protocols/public/arean/AreanTypeDef";
import {AreanLogic} from "../../SrvGame/AreanLogic/AreanLogic";

interface DBAccountInfo {
    account: string;
    password: string;
    uid: string;
    createTime?: string;
}

const accountSchema = new mongoose.Schema<DBAccountInfo>({
    account: { type: String, required: true },
    password: { type: String, required: false },
    uid: { type: String, required: true },
    createTime: { type: String, required: false }
});

const DBAccountModel = mongoose.model("DBAccount", accountSchema);
accountSchema.index({ account: 1 }, { unique: true });// 唯一索

// 2. 创建一个与 document interface 相对应的 Schema
const schema = new mongoose.Schema<DBUserInfo>({
    account: { type: String, required: true },
    uid: { type: String, required: true },
    name: { type: String, required: false },
    visualId: { type: Number, required: false },
    gender: { type: Number, required: false },
    introduction: { type: String, required: false },
    mails: { type: [String], required: false },
    coin: { type: Number, required: true,default: 100 },
    diamond: { type: Number, required: true ,default: 0 },
    heroId: { type: Number, required: true ,default: 1001 },
    danGrading: { type: Number, required: true ,default: 0 },
    frameIcon: { type: Number, required: true ,default: 0 },
    skinId: { type: Number, required: true ,default: 0 },
    title: { type: String, required: false ,default: 'this is test' },
    signature: { type: String, required: false ,default: '' },
    useFlag: { type: String, required: false ,default: '' },
    usedHeroes: { type: Array(Number), required: false ,default: [] },
    PersonalBackground: { type: String, required: false ,default: '' },
    battleCount: { type: Number, required: false ,default: 0 },
    createTime: { type: String, required: false },
});

// 定义 索引
schema.index({ uid: 1 }, { unique: true });// 唯一索引

// 注册文档模块
const DBUserModel = mongoose.model("DBUser", schema);

/**
 * 数据库-用户信息
 */
export class MongoDBUser implements DBUser {
    /**
     * 获取用户信息 通过密码
     * @param account 
     * @param password 
     * @returns 
     */
    async getUserInfoWithPassword(account: string, password: string): Promise<DBUserInfo | undefined> {

        let accountInfo = await DBAccountModel.findOne({ account: account });
        if (!accountInfo) {
            return;
        }

        let psd = TokenUtils.encodePassword(password);
        if (accountInfo.password != psd) {
            return;
        }

        return await this.getUserInfoByUid(accountInfo.uid);
    }

    public async hasUser(account: string): Promise<boolean> {
        let user_info = await DBAccountModel.findOne({ account: account });
        return user_info != null;
    }

    async insterNewUser(account: string, password: string) {
        let uid = '';
        while (true) {
            uid = TokenUtils.genID(6, true);
            let user_info = await DBUserModel.findOne({ uid: uid });
            if (!user_info) {
                break;
            }
        }
        let createTime = AreanLogic.Instance.formatDate(new Date());
        console.log(`注册的时间 == ${createTime}`);
        let newUser: DBUserInfo = {
            account: account,
            uid: uid,
            name: '',
            gender: 0,
            introduction: '',
            visualId: 0,
            mails: [],
            coin: 200,
            diamond: 0,
            heroId: 1001,
            createTime: createTime,
        };
        let pswd = TokenUtils.encodePassword(password);
        await DBAccountModel.create({ account: account, password: pswd, uid: uid,createTime : createTime });
        await DBUserModel.create(newUser);
        await dbHero?.addHero(uid, 1001,EAreanBuyType.Free);
        // await dbHero?.addHero(uid, 1002);
        // await dbHero?.addHero(uid, 1003);
        await dbDan?.initDanInfo(uid);

    }

    async getUserInfoByUid(uid: string): Promise<Readonly<DBUserInfo> | undefined> {
        let user_info = await DBUserModel.findOne({ uid: uid });
        if (!user_info) {
            return;
        }
        return user_info
    }
    async updateUserDataByUid(uid: string, new_user_info: DBUserInfo) {
        let user_model = await DBUserModel.findOne({ uid: uid });
        if (!user_model) {
            return;
        }
        Object.keys(new_user_info).forEach(key => {
            (user_model as any)[key] = (new_user_info as any)[key];
        });
        user_model.save();
    }

    getCommonUseHero(): Promise<Readonly<number[] | undefined>> {
        return Promise.resolve(undefined);
    }

    async updateDanGrading(uid: string, value: number):Promise<boolean> {
        let ret = await DBUserModel.findOneAndUpdate(
            {uid: uid},
            {$set: {danGrading: value}},
            {returnNewDocument: true});
        return true;
    }

    updateFrameId(uid: string, value: number): Promise<boolean> {
        return Promise.resolve(false);
    }

    updatePersonalBackground(uid: string, str: string): Promise<boolean> {
        return Promise.resolve(false);
    }

    updateSignature(uid: string, str: string): Promise<boolean> {
        return Promise.resolve(false);
    }

    updateTitle(uid: string, str: string): void {
    }

    updateUseFlag(uid: string, str: string): Promise<boolean> {
        return Promise.resolve(false);
    }

    async updateUseHeroId(uid: string, value: number) {
        let ret = await DBUserModel.findOneAndUpdate(
            {uid: uid},
            {$set:{heroId : value}},//$set 操作符用于设置或更新文档中的字段值。当你使用 $set 时，如果指定的字段已经存在，它将被更新为新值；如果字段不存在，它将被创建并设置为新值。
            // {$inc:{visualId : value}}, //`$inc` 操作符用于将文档中的数字字段增加一个指定的数值。`$inc` 只适用于数字类型的字段，并且只能用于增加数值，不能用于减少数值。
            { returnNewDocument: true });
        return {uid: uid,heroId: value};
    }

    updateUseSkinId(uid: string, heroId: number, value: number): Promise<boolean> {
        return Promise.resolve(false);
    }

    async updateVisualId(uid: string, value: number,frameId : number): Promise<boolean> {
        let ret = await DBUserModel.findOneAndUpdate(
            {uid: uid},
            {$set:{visualId : value,frameIcon : frameId}},//$set 操作符用于设置或更新文档中的字段值。当你使用 $set 时，如果指定的字段已经存在，它将被更新为新值；如果字段不存在，它将被创建并设置为新值。
            // {$inc:{visualId : value}}, //`$inc` 操作符用于将文档中的数字字段增加一个指定的数值。`$inc` 只适用于数字类型的字段，并且只能用于增加数值，不能用于减少数值。
            { returnNewDocument: true });
        return true;
    }

    async updateBattleCount(uid: string, value: number): Promise<boolean> {
        let ret = await DBUserModel.findOneAndUpdate(
            {uid: uid},
            {$set:{visualId : value}},//$set 操作符用于设置或更新文档中的字段值。当你使用 $set 时，如果指定的字段已经存在，它将被更新为新值；如果字段不存在，它将被创建并设置为新值。
            // {$inc:{visualId : value}}, //`$inc` 操作符用于将文档中的数字字段增加一个指定的数值。`$inc` 只适用于数字类型的字段，并且只能用于增加数值，不能用于减少数值。
            { returnNewDocument: true });
        return true;
    }

    /******************************************* 服务端方法 ****************************************/
    // 计算段位信息
    public calDanData(star : number) : {curDan : number,mainDan : number,needStar : number,curDanStar : number}{
        let data = CfgAreanMgr.DanCfg.getAllData();
        let len = data.length;
        let danInfo: any = {
            curDan : -1,
            mainDan : -1,
            needStar : -1,
            curDanStar : star
        };
        if(star > data[len - 2].allStar){
            // 越界
        }else{
            if(star === 0){
                danInfo.curDan = 1;
                danInfo.mainDan = 1;
                danInfo.needStar = data[0].allStar;
            }else{
                for (let i = 0; i < len; i++) {
                    if (star <= data[i].allStar) {
                        danInfo.curDan = i + 1;
                        danInfo.mainDan = data[i].mainDan;
                        danInfo.needStar = data[i].allStar;
                        break;
                    }
                }
            }
        }
        return danInfo;
    }

    // 更新金币
    async updateCoin(uid: string, value: number): Promise<boolean> {
        let ret = await DBUserModel.findOneAndUpdate(
            {uid: uid},
            {$set: {coin: value}},//$set 操作符用于设置或更新文档中的字段值。当你使用 $set 时，如果指定的字段已经存在，它将被更新为新值；如果字段不存在，它将被创建并设置为新值。
            // {$inc:{visualId : value}}, //`$inc` 操作符用于将文档中的数字字段增加一个指定的数值。`$inc` 只适用于数字类型的字段，并且只能用于增加数值，不能用于减少数值。
            {returnNewDocument: true});
        return true;
    }

    // 更新银币
    async updateDiamond(uid: string, value: number): Promise<boolean> {
        let ret = await DBUserModel.findOneAndUpdate(
            {uid: uid},
            {$set: {diamond: value}},//$set 操作符用于设置或更新文档中的字段值。当你使用 $set 时，如果指定的字段已经存在，它将被更新为新值；如果字段不存在，它将被创建并设置为新值。
            // {$inc:{visualId : value}}, //`$inc` 操作符用于将文档中的数字字段增加一个指定的数值。`$inc` 只适用于数字类型的字段，并且只能用于增加数值，不能用于减少数值。
            {returnNewDocument: true});
        return true;
    }
}