import UnitHelper from "../utils/unit";

var coordinateHelper = {
    /**
    * @description 得到最优坐标间隔
    */
    GetOptimalSpace(refSpace) {

        if (refSpace < 0.000001) {
            return 1;
        }
        if (refSpace < 0.01) {
            var refSpace2 = refSpace * 100;
            return coordinateHelper.GetOptimalSpace(refSpace2) / 100;
        }
        else if (refSpace < 0.1) {
            var refSpace2 = refSpace * 10;
            return coordinateHelper.GetOptimalSpace(refSpace2) / 10;
        }
        else if (refSpace < 1) {
            if (refSpace < 0.15)
                return 0.1;
            else if (refSpace < 0.22)
                return 0.2;
            //else if (refSpace < 0.32)
            //    return 0.25;
            else if (refSpace < 0.6)
                return 0.5;
            //else if (refSpace < 0.85)
            //    return 0.75;
            else
                return 1;
        }

        else if (refSpace < 3) {
            if (refSpace < 1.2)
                return 1;
            //else if (refSpace < 1.7)
            //    return 1.5;
            else if (refSpace < 2.3)
                return 2;
            //else if (refSpace < 2.7)
            //    return 2.5;
            else
                return 3;
        }
        else if (refSpace < 11) {
            if (refSpace < 5.5)
                return 5;
            //else if (refSpace < 6.5)
            //    return 6;
            //else if (refSpace < 7.8)
            //    return 7.5;
            else if (refSpace < 8.5)
                return 8;
            else
                return 10;
        }
        else if (refSpace < 16)
            return 15;
        else if (refSpace < 22)
            return 20;
        else if (refSpace < 35)
            return 25;
        else if (refSpace < 41)
            return 40;
        else if (refSpace < 51)
            return 50;
        else if (refSpace < 61)
            return 60;
        else if (refSpace < 71)
            return 70;
        else if (refSpace < 78)
            return 75;
        else if (refSpace < 150)
            return 100;
        else if (refSpace < 230)
            return 200;
        else if (refSpace < 270) {
            return 250;
        }
        else {
            if (refSpace < 1500) {
                var a = Math.ceil(refSpace / 100);
                return a * 100;
            }
            else {
                var a = Math.ceil(refSpace / 1000);
                return a * 1000;
            }
        }

    },
    /**
    * @description 由于改了单位, 重新计算坐标
    */
    CalcOptimalByUnitQ(origin_unit_q, target_unit_q, coordinate) {
        if (origin_unit_q == target_unit_q)
            return;
        var spaceQ2 = coordinateHelper.GetOptimalSpace(
            UnitHelper.ConvertQ_fromM3H(target_unit_q, coordinate.SpaceQ)
        );
        var min_q = UnitHelper.ConvertQ_fromM3H(
            target_unit_q,
            coordinate.DispMinQ
        );
        var dispMinQ2 = Math.floor(min_q / spaceQ2) * spaceQ2;
        var grid_num = 0;
        for (var i = 1; i < 25; i++) {
            var q = dispMinQ2 + spaceQ2 * i;
            var m3h = UnitHelper.ConvertQ_toM3H(target_unit_q, q);
            grid_num = i;
            if (m3h > coordinate.DispMaxQ * 1.05) {
                coordinate.DispMaxQ = m3h;
                coordinate.DispMinQ = UnitHelper.ConvertQ_toM3H(target_unit_q, dispMinQ2);
                coordinate.MinQ = coordinate.DispMinQ;
                coordinate.GridNumberX = grid_num;
                coordinate.SpaceQ = UnitHelper.ConvertQ_toM3H(target_unit_q, spaceQ2);
                break;
            }
        }
        // console.log(coordinate)
    },
    /**
    * @description 由于改了单位, 重新计算坐标
    */
    CalcOptimalByUnitH(origin_unit_h, target_unit_h, coordinate) {
        if (origin_unit_h == target_unit_h)
            return;
        var spaceH2 = coordinateHelper.GetOptimalSpace(
            UnitHelper.ConvertH_fromM(target_unit_h, coordinate.SpaceH * 1.1)
        );
        var min_h = UnitHelper.ConvertH_fromM(
            target_unit_h,
            coordinate.DispMinH
        );
        var max_h2_u = UnitHelper.ConvertH_fromM(
            target_unit_h,
            coordinate.MinH + coordinate.SpaceH * coordinate.EndLineNoH
        );
        // console.log(coordinate.MinH +  coordinate.SpaceH * coordinate.EndLineNoH,
        //     UnitHelper.ConvertH_fromM (
        //         target_unit_h,
        //         220
        //     ));
        var dispMaxH2 = Math.floor(max_h2_u / spaceH2) * spaceH2 + spaceH2;

        var grid_num = 0;
        for (var i = 0; i <= coordinate.EndLineNoH; i++) {
            var m = UnitHelper.ConvertH_toM(target_unit_h, dispMaxH2 - spaceH2 * i);
            grid_num++;
            //console.log(m,coordinate.DispMinH)
            if (m > coordinate.DispMinH || grid_num < 3) {
                continue;
            }
            else {
                break;
            }
        }

        coordinate.SpaceH = UnitHelper.ConvertH_toM(target_unit_h, spaceH2);
        coordinate.DispMaxH = UnitHelper.ConvertH_toM(target_unit_h, dispMaxH2);
        coordinate.MinH = UnitHelper.ConvertH_toM(target_unit_h, dispMaxH2 - coordinate.EndLineNoH * spaceH2);
        coordinate.StartLineNoH = coordinate.EndLineNoH - grid_num;
        coordinate.DispMinH = coordinate.MinH + coordinate.StartLineNoH * coordinate.SpaceH;

        //console.log(coordinate);
    },
    /**
    * @description 由于改了单位, 重新计算坐标
    */
    CalcOptimalByUnitP(origin_unit_p, target_unit_p, coordinate) {
        if (origin_unit_p == target_unit_p)
            return;
        var spaceP2 = coordinateHelper.GetOptimalSpace(
            UnitHelper.ConvertP_fromKW(target_unit_p, coordinate.SpaceP * 1.1)
        );
        var min_p = UnitHelper.ConvertP_fromKW(
            target_unit_p,
            coordinate.DispMinP
        );
        var max_p2_u = UnitHelper.ConvertP_fromKW(
            target_unit_p,
            coordinate.MinP + coordinate.SpaceP * coordinate.EndLineNoP
        );
        // console.log(coordinate.MinH +  coordinate.SpaceH * coordinate.EndLineNoH,
        //     UnitHelper.ConvertH_fromM (
        //         target_unit_h,
        //         220
        //     ));
        var dispMaxP2 = Math.floor(max_p2_u / spaceP2) * spaceP2 + spaceP2;

        var grid_num = 0;
        for (var i = 0; i <= coordinate.EndLineNoP; i++) {
            var m = UnitHelper.ConvertP_toKW(target_unit_p, dispMaxP2 - spaceP2 * i);
            grid_num++;
            //console.log(m,coordinate.DispMinH)
            if (m > coordinate.DispMinP || grid_num < 2) {
                continue;
            }
            else {
                break;
            }
        }

        coordinate.SpaceP = UnitHelper.ConvertP_toKW(target_unit_p, spaceP2);
        coordinate.DispMaxP = UnitHelper.ConvertP_toKW(target_unit_p, dispMaxP2);
        coordinate.MinP = UnitHelper.ConvertP_toKW(target_unit_p, dispMaxP2 - coordinate.EndLineNoP * spaceP2);
        coordinate.StartLineNoP = coordinate.EndLineNoP - grid_num;
        coordinate.DispMinP = coordinate.MinP + coordinate.StartLineNoP * coordinate.SpaceP;

        //console.log(coordinate);
    },

    /**
    * @description 由于改了单位, 重新计算坐标
    */
    CalcOptimalByUnitNPSH(origin_unit_npsh, target_unit_npsh, coordinate) {
        if (origin_unit_npsh == target_unit_npsh)
            return;
        var spaceNPSH1 = UnitHelper.ConvertH_fromM(
            target_unit_npsh, coordinate.SpaceNPSH * 1.1
        );
        var spaceNPSH2 = coordinateHelper.GetOptimalSpace(spaceNPSH1);//Ft 单位
        var dispMaxNPSH2 = UnitHelper.ConvertH_fromM(target_unit_npsh, coordinate.MinNPSH + (coordinate.EndLineNoNPSH - coordinate.StartLineNoNPSH)  * coordinate.SpaceNPSH);//Ft 单位
        var grid_num = 0;
        for (var i = 0; i <= 10; i++) {
            if (spaceNPSH2 * i < dispMaxNPSH2 ) {
                grid_num++;
                continue;
            }
            else{
                break;
            }
        }

        coordinate.SpaceNPSH = UnitHelper.ConvertH_toM(target_unit_npsh, spaceNPSH2);
        coordinate.DispMinNPSH = 0;
        coordinate.DispMaxNPSH = UnitHelper.ConvertH_toM(target_unit_npsh, grid_num * spaceNPSH2);
        coordinate.MinNPSH = 0;
        coordinate.MaxNPSH = UnitHelper.ConvertH_toM(target_unit_npsh, grid_num * spaceNPSH2);
        coordinate.StartLineNoNPSH = 0;
        coordinate.EndLineNoNPSH = grid_num;
        
        // console.log(coordinate,spaceNPSH2,spaceNPSH2,grid_num);
    }
}

export default coordinateHelper