/**设种一个随机种子保证随机结果一致
 * 后面需要可以引入 seedrandom 库
*/
class Random {
    private _seed: number;
    private _start_seed: number;
    /**当前种子*/
    public get seed(): number {
        return this._seed;
    }
    /**原始种子*/
    public get start_seed(): number {
        return this._start_seed;
    }
    /**随机种子*/
    constructor(seed: number) {
        this.set_seed(seed);
    }
    /**设置当前开始种子*/
    public set_seed(seed: number) {
        this._seed = seed;
        this._start_seed = seed;
    }
    private _nextSeed(): void {
        this._seed = (this._seed * 9301 + 49297) % 233280;
    }
    /**0.0(含)-1.0(不含)*/
    private _nextFloat(): number {
        this._nextSeed();
        return this._seed / 233280;
    }
    /**0(含)-max(不含) */
    private _nextInt(max: number): number {
        max = Math.floor(max);
        this._nextSeed();
        return this._seed % max;
    }
    /**
     * 生成指定范围的随机浮点数
     * @param min   最小值(含)
     * @param max   最大值(不含)
    */
    public float(min: number = 0, max: number = 1): number {
        return this._nextFloat() * (max - min) + min;
    }
    /**
     * 生成指定范围的随机整数
     * @param min 最小值(含)
     * @param max 最大值(不含)
     * @returns
     */
    public int(min: number = 0, max: number = 100): number {
        return this._nextInt(max - min) + Math.ceil(min);
    }
    /** 生成随机整数 -1 或 1*/
    public dir(): -1 | 1 {
        return Math.floor(this.float() * 2) === 0 ? -1 : 1;
    }
    /**
    * 在指定数组中随机取出N个不重复的数据
    * @param resArr
    * @param ranNum
    * @returns {Array}
    */
    public getDiffValueFromArr<T>(resArr: Array<T>, ranNum: number): Array<T> {
        let arr = new Array<T>();
        let result = new Array<T>();
        if (!resArr || resArr.length <= 0 || ranNum <= 0) {
            return result;
        }
        for (let i = 0; i < resArr.length; i++) {
            arr.push(resArr[i]);
        }
        if (ranNum >= arr.length) return arr;
        ranNum = Math.min(ranNum, arr.length - 1);
        for (let i = 0; i < ranNum; i++) {
            let ran = this.int(0, arr.length - 1);
            result.push(arr.splice(ran, 1)[0]);
        }
        return result;
    }
    /**
    * 生成指定范围的随机整数
     * @param min   最小值
     * @param max   最大值
     * @param type  类型
     * @example
     //type=1 [min,max) 得到一个两数之间的随机整数,这个值不小于min（如果min不是整数的话，得到一个向上取整的 min），并且小于（但不等于）max  
     //type=2 [min,max] 得到一个两数之间的随机整数，包括两个数在内,这个值比min大（如果min不是整数，那就不小于比min大的整数），但小于（但不等于）max
     //type=3 (min,max) 得到一个两数之间的随机整数
    */
    public int_type(min: number, max: number, type: number): number {
        min = Math.ceil(min);
        max = Math.floor(max);
        switch (type) {
            case 1: // [min,max) 得到一个两数之间的随机整数,这个值不小于min（如果min不是整数的话，得到一个向上取整的 min），并且小于（但不等于）max  
                return Math.floor(this._nextFloat() * (max - min)) + min;
            case 2: // [min,max] 得到一个两数之间的随机整数，包括两个数在内,这个值比min大（如果min不是整数，那就不小于比min大的整数），但小于（但不等于）max
                return Math.floor(this._nextFloat() * (max - min + 1)) + min;
            case 3: // (min,max) 得到一个两数之间的随机整数
                return Math.floor(this._nextFloat() * (max - min - 1)) + min + 1;
        }
        return 0;
    }
}
/**创建一个设定好种子的随机数实例*/
export default function get_new_random(seed: number): Random { return new Random(seed); }