const FEET_TO_INCHES_FACTOR = 12
const EIGHTHS_SYMBOLS = ["", "⅛", "¼", "⅜", "½", "⅝", "¾", "⅞"]//eighths 八分之……


class UnitOfMeasurement{//转化单位工具
    constructor(t, e, n, i){
        this.name = t,
        this.symbol = e,
        this.base = n,
        this.factor = i 
    }
    toBase(t) {//换算到base
        return t * this.factor
    }
   
    fromBase(t) {//换算到当前
        return t / this.factor
    }
}

    
    
    

/*  var o = function t(e) {
    this.gettext = e,
    t.METRIC = this.gettext("metric", void 0, "measurement system"),
    t.IMPERIAL = this.gettext("imperial", void 0, "measurement system") 
    
    
};
e.UoMSystem = o;

let UoMSystem = {
    
} */



/* var MeasurementDomain = {

    DISTANCE : "DISTANCE",
    t.AREA = "AREA",
    t.VOLUME = "VOLUME",
    t.DATA = "DATA",
    t
}
 

 */
    
    
    
    
    
     
    
var UnitsOfMeasurement = {
 
    MILLIMETER : ["Millimeter", "mm"],
    CENTIMETER : ["Centimeter", "cm"],
    METER : ["Meter", "m"],
    KILOMETER : ["Kilometer", "km"],
    INCH : ["Inch", "in"],
    FOOT : ["Foot", "ft"],
    MILE : ["Mile", "mi"],
    SQUAREMETER : ["SquareMeter", "m²"],
    SQUAREFOOT : ["SquareFoot", "ft²"],
    CUBICMETER : ["CubicMeter", "m³"],
    CUBICFOOT : ["CubicFoot", "ft³"],
    BYTE : ["Byte", "B"],
    KILOBYTE : ["Kilobyte", "kB"],
    MEGABYTE : ["Megabyte", "MB"],
    GIGABYTE : ["Gigabyte", "GB"],
    TERABYTE : ["Terabyte", "TB"],
    PETABYTE : ["Petabyte", "PB"],
    
    
    init : function() {
        var e, n, i, a, s, c, l, u, d, p, h, 
        f = new UnitOfMeasurement(UnitsOfMeasurement.METER[0],UnitsOfMeasurement.METER[1],void 0,1), 
        g = new UnitOfMeasurement(UnitsOfMeasurement.SQUAREMETER[0],UnitsOfMeasurement.SQUAREMETER[1],void 0,1), 
        m = new UnitOfMeasurement(UnitsOfMeasurement.CUBICMETER[0],UnitsOfMeasurement.CUBICMETER[1],void 0,1), 
        v = new UnitOfMeasurement(UnitsOfMeasurement.BYTE[0],UnitsOfMeasurement.BYTE[1],void 0,1);
        
        UnitsOfMeasurement.DISTANCE = (
            (e = {})['metric'] = ((n = {})[UnitsOfMeasurement.MILLIMETER[0]] = new UnitOfMeasurement(UnitsOfMeasurement.MILLIMETER[0],UnitsOfMeasurement.MILLIMETER[1],f,.001),
            n[UnitsOfMeasurement.CENTIMETER[0]] = new UnitOfMeasurement(UnitsOfMeasurement.CENTIMETER[0],UnitsOfMeasurement.CENTIMETER[1],f,.01),
            n[UnitsOfMeasurement.METER[0]] = f,
            n[UnitsOfMeasurement.KILOMETER[0]] = new UnitOfMeasurement(UnitsOfMeasurement.KILOMETER[0],UnitsOfMeasurement.KILOMETER[1],f,1e3),
            n),
            e['imperial'] = ((i = {})[UnitsOfMeasurement.INCH[0]] = new UnitOfMeasurement(UnitsOfMeasurement.INCH[0],UnitsOfMeasurement.INCH[1],f,.0254),
            i[UnitsOfMeasurement.FOOT[0]] = new UnitOfMeasurement(UnitsOfMeasurement.FOOT[0],UnitsOfMeasurement.FOOT[1],f,.3048),
            i[UnitsOfMeasurement.MILE[0]] = new UnitOfMeasurement(UnitsOfMeasurement.MILE[0],UnitsOfMeasurement.MILE[1],f,1609.344),
            i),
            e);
            
        UnitsOfMeasurement.AREA = ((a = {})['metric'] = ((s = {})[UnitsOfMeasurement.SQUAREMETER[0]] = g,
            s),
            a['imperial'] = ((c = {})[UnitsOfMeasurement.SQUAREFOOT[0]] = new UnitOfMeasurement(UnitsOfMeasurement.SQUAREFOOT[0],UnitsOfMeasurement.SQUAREFOOT[1],g,.092903),
            c),
            a);
            
        
        UnitsOfMeasurement.VOLUME = ((l = {})['metric'] = ((u = {})[UnitsOfMeasurement.CUBICMETER[0]] = m,
            u),
            l['imperial'] = ((d = {})[UnitsOfMeasurement.CUBICFOOT[0]] = new UnitOfMeasurement(UnitsOfMeasurement.CUBICFOOT[0],UnitsOfMeasurement.CUBICFOOT[1],m,.0283168),
            d),
            l);
        
        //数据大小
        var y = ((p = {})[UnitsOfMeasurement.BYTE[0]] = v,
            p[UnitsOfMeasurement.KILOBYTE[0]] = new UnitOfMeasurement(UnitsOfMeasurement.KILOBYTE[0],UnitsOfMeasurement.KILOBYTE[1],v,1e3),
            p[UnitsOfMeasurement.MEGABYTE[0]] = new UnitOfMeasurement(UnitsOfMeasurement.MEGABYTE[0],UnitsOfMeasurement.MEGABYTE[1],v,1e6),
            p[UnitsOfMeasurement.GIGABYTE[0]] = new UnitOfMeasurement(UnitsOfMeasurement.GIGABYTE[0],UnitsOfMeasurement.GIGABYTE[1],v,1e9),
            p[UnitsOfMeasurement.TERABYTE[0]] = new UnitOfMeasurement(UnitsOfMeasurement.TERABYTE[0],UnitsOfMeasurement.TERABYTE[1],v,1e12),
            p[UnitsOfMeasurement.PETABYTE[0]] = new UnitOfMeasurement(UnitsOfMeasurement.PETABYTE[0],UnitsOfMeasurement.PETABYTE[1],v,1e15),
            p);
            UnitsOfMeasurement.DATA = ((h = {})['metric'] = y,
            h['imperial'] = y,
            h)
    }
    ,
    getUnitsOfMeasurementByDomain : function(e) {
        
        return this[e.toUpperCase()]
        
        /* switch (e.toUpperCase()) {
        case a.DISTANCE:
            return t.DISTANCE;
        case a.AREA:
            return t.AREA;
        case a.VOLUME:
            return t.VOLUME;
        case a.DATA:
            return t.DATA;
        default:
            console.error(e + " measurement domain is not supported.")
        } */
    }
    ,
    getUnitsOfMeasurementByDomainAndSystem : function(domain, system) {
        var r = this.getUnitsOfMeasurementByDomain(domain);
        if (r.hasOwnProperty(system.toLowerCase()))
            return r[system.toLowerCase()];
        console.error(n + " measurement system is not supported.")
    }
    ,
    getDefaultUnitByDomainAndSystem : function(e, n) {
        switch (e.toUpperCase()) {
            case 'DISTANCE':
                switch (n.toLowerCase()) {
                case 'metric':
                    return this.DISTANCE['metric'][this.METER[0]];
                case 'imperial':
                    return this.DISTANCE['imperial'][this.FOOT[0]];
                default:
                    console.error(n + " measurement system is not supported.")
                }
            case 'AREA':
                switch (n.toLowerCase()) {
                case 'metric':
                    return this.AREA['metric'][this.SQUAREMETER[0]];
                case 'imperial':
                    return this.AREA['imperial'][this.SQUAREFOOT[0]];
                default:
                    console.error(n + " measurement system is not supported.")
                }
            case 'VOLUME':
                switch (n.toLowerCase()) {
                case 'metric':
                    return this.VOLUME['metric'][this.CUBICMETER[0]];
                case 'imperial':
                    return this.VOLUME['imperial'][this.CUBICFOOT[0]];
                default:
                    console.error(n + " measurement system is not supported.")
                }
            case 'DATA':
                switch (n.toLowerCase()) {
                case 'metric':
                    return this.DATA['metric'][this.BYTE[0]];
                case 'imperial':
                    return this.DATA['imperial'][this.BYTE[0]];
                default:
                    console.error(n + " measurement system is not supported.")
                }
            default:
                console.error(e + " measurement domain is not supported.")
        }
    }
    
   
}
    
    
    

 





class UnitService{
    
    constructor(/* e, n, i */){
          //this.LanguageService = e,
        //this.localStorageService = n,
        //this.gettext = i,
        //this.unitChanged = new r.Signal,
        this.LOCAL_STORAGE_KEY = "iv_unit_key"//?
        UnitsOfMeasurement.init()
        this.unitSystems = ['metric', 'imperial']//[o.UoMSystem.METRIC, o.UoMSystem.IMPERIAL],
        this.defaultSystem = 'metric'//'imperial'
        //var a = this.LanguageService.getBrowserLocaleString().toLowerCase();
        //this.defaultSystem =  t.isLocaleImperial(a) ? o.UoMSystem.IMPERIAL : o.UoMSystem.METRIC,
        
        //this.initUnit()
        
    }
     
    
    /* initUnit() {
        var t = this.localStorageService.get(this.LOCAL_STORAGE_KEY);
        if (t)
            for (var e = 0, n = this.unitSystems; e < n.length; e++) {
                var i = n[e];
                if (i === t)
                    return void this.setUnit(i, !0)
            }
        this.setUnit(this.defaultSystem, !1)
    }
    setUnit(t, e) {
        this.currentSystem !== t && (this.currentSystem = t,
        this.unitChanged.emit()),
        e && this.localStorageService.set(this.LOCAL_STORAGE_KEY, t)
    } */
    
   
    
    /*isLocaleImperial(e) {
        return t.IMPERIAL_LOCALES.indexOf(e.toLowerCase()) >= 0
    }
    ,
     t.IMPERIAL_LOCALES = ["en_us"],
    t.ɵfac(e) {
        return new (e || t)(c.ɵɵinject(l.LanguageService),
        c.ɵɵinject("localStorageService"),c.ɵɵinject("gettext"))
    }
     ,
    t.ɵprov = c.ɵɵdefineInjectable({
        token: t,
        factory: t.ɵfac,
        providedIn: "root"
    }), */
    
} 



    

class UoMService{
    constructor(/* UnitService */){
        this.UnitService = new UnitService()/* UnitService */
        
    }
    scopedConvert (t, n, precision = 2, r, minFactor) {
        return  this.convert(t, n, precision, r, minFactor)
    }
    
    convert(number, domain, precision = 2, system, minFactor, ifEighths = !1, ifRestrictFactor) { 
        if (!number) return "";
        var s = this.getMostRelevantMeasurement(domain, system || this.UnitService.currentSystem, number, minFactor, ifRestrictFactor);
        return this.getFormattedMeasurementString(s[0], s[1], precision, ifEighths)
    }
    
    convertBack(number, domain, precision = 2, fromSystem, minFactor ) { //从英制转到'metric'
        if (!number) return "";
        var d = UnitsOfMeasurement.getDefaultUnitByDomainAndSystem(domain,'metric')
        
        var s = this.getMostRelevantMeasurement2(domain, fromSystem, number, minFactor);
        return this.getFormattedMeasurementString(s[0], d, precision ) 
        
        
        /* 栗子：
        viewer.unitConvert.convertBack(1, 'area', 5, 'imperial')
        '0.09290 m²'
        viewer.unitConvert.convertBack(1, 'Distance', 2, 'imperial')
        '0.03 m' 
        */
    }
    
    getFormattedMeasurementString(number, unit, precision, ifEighths) {
        var result 
        if(ifEighths && unit.name === UnitsOfMeasurement.FOOT[0]){
            result = this.formatImperialDistance(number * FEET_TO_INCHES_FACTOR)
        }else if(ifEighths && unit.name === UnitsOfMeasurement.INCH[0]){
            result = this.formatImperialDistance(number)
             
        }else{
            result = number.toLocaleString(void 0, {
                minimumFractionDigits: precision,
                maximumFractionDigits: precision
            }) + " " + unit.symbol
        }
        
        return result
    }
    
    formatImperialDistance(e) {
        var n = Math.round(8 * e)
          , i = Math.floor(n / 8)
          , r = Math.floor(i / FEET_TO_INCHES_FACTOR)
          , o = i - r * FEET_TO_INCHES_FACTOR
          , a = EIGHTHS_SYMBOLS[n % 8]
          , s = 0 === o && "" !== a ? "" : o;
          
        "" !== s && "" !== a && (a = " " + a)   
        
        return  0 !== r ? r + "' " + s + a + '"' : "" + s + a + '"'
    }
    
    getMostRelevantMeasurement(domain, system, number, minFactor=0, ifRestrictFactor) {
        /* var a = r.values(UnitsOfMeasurement.getUnitsOfMeasurementByDomainAndSystem(domain, system))
          , s = r.filter(a, function(t) {  
            return t.factor >= i
        })
          , c = r.reduce(s, function(t, e) {
            return e.fromBase(number) < t.fromBase(number) && e.fromBase(number) >= 1 ? e : t
        }); */
        let a = []
        let u = UnitsOfMeasurement.getUnitsOfMeasurementByDomainAndSystem(domain, system)
        for(let i in u){a.push(u[i])}
         
        let s   
        if(ifRestrictFactor){//是否只用这一单位，如只用mm。如果不是，就会寻找最大的接近的单位，如设置最小为mmminFactor=0.001），则1.2米时是'1.2m'、0.2米时是'20cm'、0.002米时是'2mm'
            s = a.filter(m=>m.factor == minFactor)  
        }else{
            s = a.filter(m=>m.factor >= minFactor)
        } 
       
        let c = s.reduce(function(prev, currentValue) {//reduce最终值是最后一次return的值 （ 没看懂这句话作用） 
            return currentValue.fromBase(number) < prev.fromBase(number) && currentValue.fromBase(number) >= 1 ? currentValue : prev
        })
        
        return c ? [c.fromBase(number), c] : void 0
    }
    
    getMostRelevantMeasurement2(domain, system, number, minFactor=0) {//add
        let a = []
        let u = UnitsOfMeasurement.getUnitsOfMeasurementByDomainAndSystem(domain, system)
        for(let i in u){a.push(u[i])} 
        let s = a.filter(m=>m.factor >= minFactor)  
        let c = s.reduce(function(prev, currentValue) {//reduce最终值是最后一次return的值 （ 没看懂这句话作用） 
            return currentValue.toBase(number) < prev.toBase(number) && currentValue.toBase(number) >= 1 ? currentValue : prev
        }) 
        return c ? [c.toBase(number), c] : void 0
    }
    /* ɵfac(e){
        return new (e || t)(c.ɵɵinject(l.UnitService))
    }
    
    ɵprov = c.ɵɵdefineInjectable({
        token: t,
        factory: t.ɵfac,
        providedIn: "root"
    }) */
   
}


/* 
使用方法：


初始化：
    var unitConvert = new UoMService();
 
    要设置的类型，两种：var unitSystem = 'metric' || 'imperial'  
 

使用：

    面积：
        let text = viewer.unitConvert.convert(area, 'area', void 0,  unitSystem,  )  

    长度：
        var text = viewer.unitConvert.convert(distance, 'distance', void 0, unitSystem, 0.1 , true)//distance要传0.1这个factor。 最后一个参数传true代表使用八分之一表示。

 */



export {UoMService}