import { Vec2 } from "cc";

export class MathUtil {

    public randomSeed: number = null
    /**
     * 获取范围内的随机数(min <= {return}} <= max)
     * @param min 最小值
     * @param max 最大值
     */
    static getRandom(min: number, max: number) {
        if (min == max) {
            return min;
        }
        return (min >= max) ? 0 : Math.floor(Math.random() * (max - min + 1)) + min;
    }

    /**
     * 获取随机数 
     * @param min 
     * @param max 
     * @param seed 随机种子
     * @param isFloor 是否取整数
     * @returns 
     */
    static getRandomBySeed(min: number, max: number, seed: number, isFloor?: boolean) {
        max = max || 1
        min = min || 0
        seed = (seed * 9301 + 49297) % 233280
        let rnd = seed / 233280
        if (isFloor) {
            return Math.floor(min + rnd * (max - min))
        } else {
            return min + rnd * (max - min)
        }
    }


    /**
     * 百分比出现几率
     * @param percentage 
     * @returns 
     */
    static getRandomPercentage(percentage: number) {
        let random = this.getRandom(0, 100)
        if (random < percentage) {
            return true
        }

        return false
    }

    /**
     * 定和随机分配(getRandomBySumList(5,100):随机5个整数,5个数的和为100)
     * @param count 数量
     * @param sum 定和
     */
    static getRandomBySumList(count: number, sum: number): number[] {
        var residue = sum;
        var value = 0;
        var result: Array<number> = [];
        for (let i = 0; i < count; i++) {
            value = this.getRandom(1, residue - 1);
            if (i == count - 1) {
                value = residue;
            } else {
                residue -= value;
            }
            result.push(value);
        }
        return result;
    }

    /**
     * 两点之间的角度
     * @param pos1 坐标1
     * @param pos2 坐标2
     */
    static getAngle(pos1: Vec2, pos2: Vec2) {
        return Math.atan2(pos1.y - pos2.y, pos1.x - pos2.x) * (180 / Math.PI);
    }

    /**
     * 将角度转为弧度
     * @param angle 角度
     */
    static angleToRadian(angle: number) {
        return angle * Math.PI / 180;
    }

    /**
     * 将弧度转为角度
     * @param radian 弧度
     */
    static radianToAngle(radian: number) {
        return radian / Math.PI * 180;
    }

    /**
     * 获取两向量的夹角
     * @param vector1 向量1
     * @param vector2 向量2
     */
    static getVectorAngle(vector1: Vec2, vector2: Vec2) {
        return (Math.atan2(vector2.y, vector2.x) - Math.atan2(vector1.y, vector1.x)) * (180 / Math.PI);
    }

    /**
     * 将角度转为向量
     * @param angle 角度
     */
    static angleToVector(angle: number) {
        let radian = this.angleToRadian(angle);
        return new Vec2(Math.cos(radian), Math.sin(radian)).normalize();
    }

    /**
     * 将向量转为角度
     * @param vector 向量
     */
    static vectorToAngle(vector: Vec2) {
        let dir = vector.normalize();
        let radian = dir.signAngle(new Vec2(1, 0));
        return -this.radianToAngle(radian);
    }

    static isInteger(num: number) {
        return (num <= 0) ? false : Math.round(num) === num;
    }
    //乘法函数，用来得到精确的乘法结果
    //说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。
    //调用：accMul(arg1,arg2)
    //返回值：arg1乘以arg2的精确结果
    static accMul(arg1, arg2) {
        var m = 0, s1 = arg1.toString(), s2 = arg2.toString();
        try { m += s1.split(".")[1].length } catch (e) { }
        try { m += s2.split(".")[1].length } catch (e) { }
        return Number(s1.replace(".", "")) * Number(s2.replace(".", "")) / Math.pow(10, m);
    }
    //加法函数，用来得到精确的加法结果
    //说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
    //调用：accAdd(arg1,arg2)
    //返回值：arg1加上arg2的精确结果
    static accAdd(arg1, arg2) {
        var r1, r2, m;
        try { r1 = arg1.toString().split(".")[1].length } catch (e) { r1 = 0 }
        try { r2 = arg2.toString().split(".")[1].length } catch (e) { r2 = 0 }
        m = Math.pow(10, Math.max(r1, r2));
        return (arg1 * m + arg2 * m) / m;
    }

    //减法函数
    static accSub(arg1, arg2) {
        var r1, r2, m, n;
        try { r1 = arg1.toString().split(".")[1].length } catch (e) { r1 = 0 }
        try { r2 = arg2.toString().split(".")[1].length } catch (e) { r2 = 0 }
        m = Math.pow(10, Math.max(r1, r2));
        //last modify by deeka
        //动态控制精度长度
        n = (r1 >= r2) ? r1 : r2;
        return ((arg2 * m - arg1 * m) / m).toFixed(n);
    }
}