BemsWebApplication.MainDashboard = function(params, viewInfo) {
    "use strict";

    var
        ELECTRICITY_DAY_MAX = 50000, // 전기금일목표
        ELECTRICITY_MONTH_MAX = 1000000, //전기이달목표
        ELECTRICITY_YEAR_MAX = 9000000,
        ELECTRICITY_GOAL_YEAR = 101165200, // 백만kWh

        GAS_DAY_MAX = 40000,
        GAS_MONTH_MAX = 100000,
        GAS_YEAR_MAX = 800000,
        GAS_GOAL_YEAR = 3708099, // 

        WATER_DAY_MAX = 15000,
        WATER_MONTH_MAX = 4000000,
        WATER_YEAR_MAX = 5000000,
        WATER_GOAL_YEAR = 682772;
/*
        ELECTRICITY_YEAR_MAX = ELECTRICITY_GOAL_YEAR + ELECTRICITY_GOAL_YEAR * 0.7,
        GAS_YEAR_MAX = GAS_GOAL_YEAR + GAS_GOAL_YEAR * 0.7, // 
        WATER_YEAR_MAX = WATER_GOAL_YEAR + WATER_GOAL_YEAR * 0.7; // 10%를 최대값으로 */
        
    var todayDayValue = ko.observableArray();//  시간데이터와 일 데이터가 계속 맞지 않아 에너지사용현황은 Daily에서 읽어오도록 수정 hcLee 2016 03 18

    var timer;

    var formulaGet = new BWA.Chart.FormulaGet(BWA.UserInfo.SiteId()),
        energyUsageStatusGet = new BWA.Chart.EnergyUsageStatusGet(BWA.UserInfo.SiteId());

    var chartOption = BWA.ChartOptions.MainDashBoard;

    var factorCo2 = null,
        factorToe = null;


    var CODE = $Code,
        FuelType = CODE.FuelType,
        FT = CODE.FacilityType,
        FC = CODE.FacilityCode,
        F = CODE.Formula,
        TIT = CODE.TimeIntervalType;

    var gaugeDataOptions = {};

    var DAY_ENERGY_USAGE    = 0,
        DAY_CO2_USAGE       = 1,
        MONTH_ENERGY_USAGE  = 2,
        MONTH_CO2_USAGE     = 3,
        YEAR_ENERGY_USAGE   = 4,
        YEAR_CO2_USAGE      = 5;

    var initialized = false,
        shouldReload = false,

        fuelTypesDataSourceMD = BemsWebApplication.db.createDataSource('BemsFuelType'),
        factorCo2DataSource = BemsWebApplication.db.createDataSource('BemsFactorCo2'),
        factorToeDataSource = BemsWebApplication.db.createDataSource('BemsFactorToe'),

        //fuelTypesDataSource = BemsWebApplication.db.createDataSource('BemsFuelType'),
        dailyDataSource = BemsWebApplication.db.createDataSource('BemsMonitoringPointHistoryDaily'),
        hourlyDataSource = BemsWebApplication.db.createDataSource('BemsMonitoringPointHistoryHourly'),

        todayCheck = ko.observable(true),
        yesterdayCheck = ko.observable(true),
        lastWeekCheck = ko.observable(false),
        thisMonthCheck = ko.observable(true),
        lastMonthCheck = ko.observable(true),
        lastYearCheck = ko.observable(false),

        todayValue = ko.observable(0),
        yesterdayValue = ko.observable(0),
        lastWeekValue = ko.observable(0),
        thisMonthValue = ko.observable(0),
        lastMonthValue = ko.observable(0),
        lastYearValue = ko.observable(0),

        // hcLee 2016 03 18
        currentTemp = ko.observable(0),
        currentHumi = ko.observable(0),

        yearElectricityUsageValue = ko.observable(0),
        yearGasUsageValue = ko.observable(0),
        yearWaterUsageValue = ko.observable(0),

        currentTabIndex = ko.observable(0),
        dataSource;

    var dayEnergyUsageChart         = BWA.Chart.Instance('dayEnergyUsageChart', 'dxChart'),
        monthEnergyUsageChart       = BWA.Chart.Instance('monthEnergyUsageChart', 'dxChart'),

        yearElectricityUsageGauge   = BWA.Chart.Instance('yearElectricityUsageGauge', 'dxCircularGauge'),
        yearGasUsageGauge           = BWA.Chart.Instance('yearGasUsageGauge', 'dxCircularGauge'),
        yearWaterUsageGauge         = BWA.Chart.Instance('yearWaterUsageGauge', 'dxCircularGauge'),
        yearEnergyUsageGauge        = BWA.Chart.Instance('yearEnergyUsageGauge', 'dxCircularGauge'),

        energyUsageRatioPieChart    = BWA.Chart.Instance('energyUsageRatioPieChart', 'dxPieChart'),
        
        rateGauges = [];

    var fuelTypes = ko.observableArray([]),
        fuelTypeId = ko.observable(),
        
        todayEnergyStatusArray = ko.observableArray(),
        yesterdayEnergyStatusArray = ko.observableArray(),
        lastWeekEnergyStatusArray = ko.observableArray(),

        thisMonthEnergyStatusArray = ko.observableArray(),
        lastMonthEnergyStatusArray = ko.observableArray(),
        lastYearEnergyStatusArray = ko.observableArray()
    ;


    //    monthEnergyDataSource(dayEnergyDataSource());


    var pieDataSource = ko.observableArray();


    function handleCmBuildingModification() {
        shouldReload = true;
    }

    var initialized = false;

    function setGaugeValue(id, value, unit) {
        var jq = $('#' + id);

        jq.cwGauge('option', 'value', BWA.DataUtil.getNumberStringWithComma(value));
        jq.cwGauge('option', 'unit', unit);
        //jq.cwGauge2(BWA.DataUtil.getNumberStringWithComma(value), unit);
    }

    function handleViewShown() {
        //window.$SearchView.isNotUse(true); 

        if (initialized === false) {

            var gaugeOptions = [
                { id: 'dayEnergyUsage', title: $G('dayEnergyUsgae'), unit: '(kWh)', colorType: 1, value: 0 },
                { id: 'dayCo2Usage', title: $G('dayCo2Usgae'), unit: '(tCO2)', colorType: 1, value: 0 }, // 사용안함
                { id: 'monthEnergyUsage', title: $G('monthEnergyUsgae'), unit: '(kWh)', colorType: 2, value: 0 },
                { id: 'monthCo2Usage', title: $G('monthCo2Usgae'), unit: '(tCO2)', colorType: 2, value: 0 },
                { id: 'yearEnergyUsage', title: $G('yearEnergyUsgae'), unit: '(kWh)', colorType: 3, value: 0 },
                { id: 'yearCo2Usage', title: $G('yearCo2Usgae'), unit: '(tCO2)', colorType: 3, value: 0 }
            ];

            _.each(gaugeOptions, function(options, i) {
                rateGauges[i] = new BWA.Chart.RateGauge.newInstance(_.extend(options, { 
                    height: '86px'
                }));
            });
            //rateGauges[DAY_ENERGY_USAGE].setValue(4124);
            //rateGauges[DAY_CO2_USAGE].setValue(4124);
            //rateGauges[MONTH_ENERGY_USAGE].setValue(7124);
            //rateGauges[MONTH_CO2_USAGE].setValue(6124);
            //rateGauges[YEAR_ENERGY_USAGE].setValue(10124);
            //rateGauges[YEAR_CO2_USAGE].setValue(10124);

            dayEnergyUsageChart = dayEnergyUsageChart(chartOption.getTodayEnergyUsageStatusChartOptions());
            monthEnergyUsageChart = monthEnergyUsageChart(chartOption.getMonthEnergyUsageStatusChartOptions());

            yearElectricityUsageGauge = yearElectricityUsageGauge(chartOption.getYearElectricityUsageStatusChartOptions());  
            yearGasUsageGauge = yearGasUsageGauge(chartOption.getYearGasUsageStatusChartOptions());
            yearWaterUsageGauge = yearWaterUsageGauge(chartOption.getYearWaterUsageStatusChartOptions());
            yearEnergyUsageGauge = yearEnergyUsageGauge(chartOption.getYearTotalEnergyUsageStatusChartOptions());

            //            yearElectricityUsageGauge().value(612772);
            energyUsageRatioPieChart = energyUsageRatioPieChart(chartOption.getUsageRatioByEnergyChartOptions());

            gaugeDataOptions[FT.ELECTRICITY] = {
                gauge: yearElectricityUsageGauge,
                max: ELECTRICITY_YEAR_MAX,
                value: yearElectricityUsageValue
            }; 
            gaugeDataOptions[FT.GAS] = {
                gauge: yearGasUsageGauge,
                max: GAS_YEAR_MAX,
                value: yearGasUsageValue
            };
            gaugeDataOptions[FT.WATER] = {
                gauge: yearWaterUsageGauge,
                max: WATER_YEAR_MAX,
                value: yearWaterUsageValue
            };
            //setGaugeRangeContainer(yearElectricityUsageGauge, ELECTRICITY_GOAL_YEAR);
            //setGaugeRangeContainer(yearGasUsageGauge, GAS_GOAL_YEAR);
            //setGaugeRangeContainer(yearWaterUsageGauge, WATER_GOAL_YEAR);

            var whenPromise = $.when(fuelTypesDataSourceMD.load(),
                   factorCo2DataSource.load(),
                   factorToeDataSource.load())

            .then(function (dbfuelTypes, dbfactorsCo2, dbfactorsToe) {

                factorCo2 = BWA.Bems.refineFactorCo2DataArray(dbfactorsCo2[0]);
                factorToe = BWA.Bems.refineFactorToeDataArray(dbfactorsToe[0]);

                fuelTypeId($Code.FuelType.ELECTRICITY);
                fuelTypes(_.rest(dbfuelTypes[0]));

                initialized = true;

            });
           
        }

        load();

        if (shouldReload) {
            //shouldReload = false;
            //dataSource.pageIndex(0);
            //dataSource.load();
        }
        $SideMenu.showSideMenuIfWill(params.view);

        //sideOverlayVisible(true);
        timer = setInterval(function () {
            var now = new Date();
            if ((now.getMinutes() % 15 == 0) && (now.getSeconds() == 59)) {
                load();
                /*
                setupRateGaugeByFuelType(fuelTypeId());
                setupTodayEnergyUsageStatusSeries();
                setupMonthEnergyUsageStatusSeries();
                loadTodayEnergyUsage(fuelTypeId());
                loadMonthEnergyUsage(fuelTypeId());*/
            }
        }, 1000);

        $('#sidemenubutton').hide(); // hcLee 2015 12 08

    }

    function handleViewDisposing() {
    }

    function handleViewHidden() {
        clearInterval(timer); // hcLee 2015 06 12
        $('#sidemenubutton').show(); // hcLee 2015 12 08
    }

    var eq = BWA.DataUtil.constructEqualFilter;
    var and = BWA.DataUtil.andFilter;
    var fcode = $Code.FacilityCode;
    var selectedFacilityCode = fcode.ELECTRICITY;


    function handleViewShowing() {
 
    }

    function setUsageStatusDataIntoList(sourceData, destlist, momentTimeField, valueField) {

        _.each(sourceData, function(data) {
            var item = {
                DateTime: moment(data.DateTime)[momentTimeField](),
            };
            item[valueField] = data.Value;
            destlist.push(item);
        });
    }

    function getDayUsageStatusDataList() {

        var list = [];
        setUsageStatusDataIntoList(todayEnergyStatusArray(), list, 'hours', 'TodayValue');
        setUsageStatusDataIntoList(yesterdayEnergyStatusArray(), list, 'hours', 'YesterdayValue');
        setUsageStatusDataIntoList(lastWeekEnergyStatusArray(), list, 'hours', 'LastWeekValue');
        return list;
    }

    function loadTodayEnergyUsage(fuelTypeId) {

        var request = energyUsageStatusGet.requestGetForUsgaeStatus(fuelTypeId, TIT.HOUR);

        //var requestd = energyUsageStatusGet.requestGetForUsgaeStatus(fuelTypeId, TIT.DAY);

        var lastWeekMoment = moment().subtract(7, 'days');
        var yesterdayMoment = moment().subtract(1, 'days');
        var todayMoment = moment();

        $.when(
            request(lastWeekMoment.clone().startOf('day'), lastWeekMoment.endOf('day')),
            request(yesterdayMoment.clone().startOf('day'), yesterdayMoment.endOf('day')),
            request(todayMoment.clone().startOf('day'), todayMoment))
            //requestd(todayMoment.clone().startOf('day'), todayMoment)) // 추가 todayDayData 추가 hcLee 2016 03 18

        .done(function (lastWeekData, yesterdayData, todayData, todayDayData) { // todayDayData 추가 hcLee 2016 03 18

            yesterdayEnergyStatusArray(yesterdayData[0]);
            lastWeekEnergyStatusArray(lastWeekData[0]);
            todayEnergyStatusArray(todayData[0]);

            //todayDayValue(todayDayData[0]);  /// todayDayData 추가 hcLee 2016 03 18

            // 2017 01 10 hcLee
            if (fuelTypeId == FuelType.WATER)
                dayEnergyUsageChart().option('valueAxis.label', { format: 'largeNumber', precision: 2 });
            else
                dayEnergyUsageChart().option('valueAxis.label', { format: 'largeNumber' });

            dayEnergyUsageChart().option('dataSource', getDayUsageStatusDataList());

        });
    }

    function loadMonthEnergyUsage(fuelTypeId) {

        var request = energyUsageStatusGet.requestGetForUsgaeStatus(fuelTypeId, TIT.DAY);
        
        var lastYearMoment = moment().subtract(1, 'years');
        var lastMonthMoment = moment().subtract(1, 'months');
        var thisMonthMoment = moment();

        $.when(
            request(lastYearMoment.clone().startOf('months'), lastYearMoment.endOf('months')),
            request(lastMonthMoment.clone().startOf('months'), lastMonthMoment.endOf('months')),
            request(thisMonthMoment.clone().startOf('months'), thisMonthMoment))

        .done(function(lastYearData, lastMonthData, thisMonthData) {

            lastYearEnergyStatusArray(lastYearData[0]);
            lastMonthEnergyStatusArray(lastMonthData[0]);
            thisMonthEnergyStatusArray(thisMonthData[0]);

            var list = [];
            setUsageStatusDataIntoList(thisMonthEnergyStatusArray(), list, 'date', 'ThisMonthValue');
            setUsageStatusDataIntoList(lastMonthEnergyStatusArray(), list, 'date', 'LastMonthValue');
            setUsageStatusDataIntoList(lastYearEnergyStatusArray(), list, 'date', 'LastYearValue');

            // 2017 01 10 hcLee
            if (fuelTypeId == FuelType.WATER)
                monthEnergyUsageChart().option('valueAxis.label', { format: 'largeNumber', precision: 2 });
            else
                monthEnergyUsageChart().option('valueAxis.label', { format: 'largeNumber' });

            monthEnergyUsageChart().option('dataSource', list);
        });
    }

    function load() {
        // 파라미터 값들을 로드
           
            var startDateInYear = moment().startOf('year'),
                endDateInYear = moment();

            var param =
            {
                SiteId: BWA.UserInfo.SiteId(),
                BuildingId: 1, // 의미없음
                FuelType:1, // 의미없음
                StartDate: startDateInYear,// 의미없음
                EndDate: endDateInYear // 의미없음
            };
            $.when(BWA.api.post('BemsMonitoringPointHistory/GetPrediction', param)) // 오늘,이달,금년 모두 한번에 온다
            .done(function (goals)
            {
                ELECTRICITY_DAY_MAX = goals[0];
                //2017 01  가스 목표량은 Kw 이다 해서 아래와 같이 처리한다 hcLee
                //GAS_DAY_MAX = goals[1];
                GAS_DAY_MAX = factorToe.calculate(goals[1], FuelType.ELECTRICITY) / factorToe[FuelType.GAS].pureFactor; ;
                WATER_DAY_MAX = goals[2];

                ELECTRICITY_MONTH_MAX = goals[3];
                //2017 01  가스 목표량은 Kw 이다 해서 아래와 같이 처리한다 hcLee
                //GAS_MONTH_MAX = goals[4];
                GAS_MONTH_MAX = factorToe.calculate(goals[4], FuelType.ELECTRICITY) / factorToe[FuelType.GAS].pureFactor;;
                WATER_MONTH_MAX = goals[5];


                ELECTRICITY_YEAR_MAX = goals[6];
                //2017 01  가스 목표량은 Kw 이다 해서 아래와 같이 처리한다 hcLee
                //GAS_YEAR_MAX = goals[7];
                GAS_YEAR_MAX = factorToe.calculate(goals[7], FuelType.ELECTRICITY) / factorToe[FuelType.GAS].pureFactor;;
                WATER_YEAR_MAX = goals[8];

                //
                gaugeDataOptions[FT.ELECTRICITY].max = ELECTRICITY_YEAR_MAX;
                gaugeDataOptions[FT.GAS].max = GAS_YEAR_MAX;
                gaugeDataOptions[FT.WATER].max = WATER_YEAR_MAX;

                //var promises = [whenPromise];
                var promises = [];
                _.each(BWA.Chart.EnergyUsageStatusGet.SearchConditions, function (x) {
                    var gaugeDataOption = gaugeDataOptions[x.FacilityTypeId];
                    var p = formulaGet.apiGet(_.extend(x, {
                        TimeIntervalType: TIT.YEAR,
                        StartDate: startDateInYear,
                        EndDate: endDateInYear

                    }))
                    .then(getCircularChartValueFunc(gaugeDataOption));
                    promises.push(p);
                });
                // 금년 목표 대비 에너지 사용 비율 모두 로드 한 후에 TOE 계산하여 적용
                $.when.apply(null, promises).then(function () {

                    var maxToe = factorToe.calculate(ELECTRICITY_YEAR_MAX, FuelType.ELECTRICITY) + factorToe.calculate(GAS_YEAR_MAX, FuelType.GAS) +
                        factorToe.calculate(WATER_YEAR_MAX, FuelType.WATER);

                    var toeElectricity = factorToe.calculate(yearElectricityUsageValue(), FuelType.ELECTRICITY);
                    var toeGas = factorToe.calculate(yearGasUsageValue(), FuelType.GAS);
                    var toeWater = factorToe.calculate(yearWaterUsageValue(), FuelType.WATER);

                    var toe = toeElectricity + toeGas + toeWater;

                    yearEnergyUsageGauge().value(toe / maxToe * 100);
                    //yearEnergyUsageGauge().value(60);

                    setupRateGaugeByFuelType(fuelTypeId());

                    pieDataSource([
                        { energy: "전기", value: toeElectricity },
                        { energy: "가스", value: toeGas },
                        { energy: "수도", value: toeWater },
                    ]);

                    loadTotalCo2ToDay();
                    loadTotalCo2Month();
                    loadTotalCo2Year();

                    var promisesTH = [];
                    var todayMoment = moment();
                    var commonParameters = {
                        TimeIntervalType: TIT.DAY,
                        StartDate: todayMoment.clone().startOf('day'),
                        EndDate: todayMoment
                    };

                    // 2016 06 29 추가
                    var commonParametersForTH = {
                        TimeIntervalType: TIT.QUARTERMIN,
                        StartDate: todayMoment.clone().startOf('day'),
                        EndDate: todayMoment
                    };

                    var temperatureParameters = {
                        FacilityTypeId: FT.OUTDOOR,
                        FacilityCode: FC.OUTDOOR,
                        FormulaId: F[FT.OUTDOOR].TEMPERATURE,
                    };

                    var humidityParameters = _.extend({}, temperatureParameters, {
                        FormulaId: F[FT.OUTDOOR].HUMIDITY,
                    });

                    promisesTH.push(formulaGet.apiGet(_.extend(temperatureParameters, commonParametersForTH)));
                    promisesTH.push(formulaGet.apiGet(_.extend(humidityParameters, commonParametersForTH)));
                    $.when.apply(this, promisesTH)
                    .done(function (OUTtemperatures, humidities) {
                        if (OUTtemperatures[0].length > 0)
                            currentTemp(OUTtemperatures[0][OUTtemperatures[0].length-1].Value.toFixed(2) + " °C");
                        if (humidities[0].length > 0)
                            currentHumi(humidities[0][humidities[0].length - 1].Value.toFixed(2) + " %");


                        setupTodayEnergyUsageStatusSeries();
                        setupMonthEnergyUsageStatusSeries();
                        loadTodayEnergyUsage(fuelTypeId());
                        loadMonthEnergyUsage(fuelTypeId());


                    })


                });

            });
            //여기서 전체 Co2별도 계산 hcLee 2015 06 29
            //rateGauges[DAY_CO2_USAGE].setValue(1.1);
            //rateGauges[MONTH_CO2_USAGE].setValue(2.2);
            //rateGauges[YEAR_CO2_USAGE].setValue(3.3);
        //});

    }

    function loadTotalCo2ToDay() {

        var now = new Date();

        var startDate, endDate;

        startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() , 0, 0, 0);
        endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 23, 59, 59);

        var promises = [];
        _.each($Code.g_fuelTypes, function (x) {
            //promises.push(energyUsageStatusGet.requestGetForUsgaeStatus(x.FuelTypeId(), TIT.HOUR)(startDate, endDate)); // 2015 06 08 수정 CO2과 똑같이 
            promises.push(energyUsageStatusGet.requestGetForUsgaeStatus(x.FuelTypeId(), TIT.DAY)(startDate, endDate)); // 2015 06 08 수정 CO2과 똑같이 
        });

        $.when.apply(this, promises).done(function () {
            var Esum = 0;
            var TotalCO2 = 0;
            _.each(arguments, function (array, i) {
                var field = $Code.g_fuelTypes[i].Name();
                
                _.each(array[0], function (x) {
                    Esum += x.Value;
                });
                TotalCO2 += factorCo2.calculate(Esum, $Code.g_fuelTypes[i].FuelTypeId());
                Esum = 0;
            });

            //TotalCO2
            rateGauges[DAY_CO2_USAGE].setValue(Math.round(TotalCO2 * 100) / 100);
        });
    }

    function loadTotalCo2Month() {
        var now = new Date();

        var startDate, endDate;

        var monthMoment;
        monthMoment = moment().month(now.getMonth());

        startDate = monthMoment.startOf('month');
        endDate = monthMoment.clone().endOf('month');

        //startDate = new Date(now.getFullYear(), now.getMonth(), 1, 0, 0, 0);
        //endDate = new Date(now.getFullYear(), now.getMonth(), 31, 23, 59, 59);
        var promises = [];

        _.each($Code.g_fuelTypes, function (x) {
            promises.push(energyUsageStatusGet.requestGetForUsgaeStatus(x.FuelTypeId(), TIT.DAY)(startDate, endDate)); // 2015 06 08 수정 CO2과 똑같이 
        });

        $.when.apply(this, promises).done(function () {
            var Esum = 0;
            var TotalCO2 = 0;
            _.each(arguments, function (array, i) {
                var field = $Code.g_fuelTypes[i].Name();

                _.each(array[0], function (x) {
                    //sum += factorCo2.calculate(x.Value, $Code.g_fuelTypes[i].FuelTypeId());
                    Esum += x.Value;
                });
                TotalCO2 += factorCo2.calculate(Esum, $Code.g_fuelTypes[i].FuelTypeId());
                Esum = 0;
            });

            //rateGauges[MONTH_CO2_USAGE].setValue(Math.floor(TotalCO2 * 100) / 100);
            rateGauges[MONTH_CO2_USAGE].setValue(Math.round(TotalCO2 * 100) / 100);
        });
    }

    function loadTotalCo2Year() {
        var now = new Date();

        var startDate, endDate;

        startDate = moment().startOf('year')
        endDate = new Date(now.getFullYear(), now.getMonth(), 31, 23, 59, 59);
        var promises = [];
        _.each($Code.g_fuelTypes, function (x) {
            promises.push(energyUsageStatusGet.requestGetForUsgaeStatus(x.FuelTypeId(), TIT.DAY)(startDate, endDate)); // 2015 06 08 수정 CO2과 똑같이 
        });

        $.when.apply(this, promises).done(function () {
            var Esum = 0;
            var TotalCO2 = 0;
            _.each(arguments, function (array, i) {
                var field = $Code.g_fuelTypes[i].Name();

                _.each(array[0], function (x) {
                    Esum += x.Value;
                });
                TotalCO2 += factorCo2.calculate(Esum, $Code.g_fuelTypes[i].FuelTypeId());
                Esum = 0;
            });

            var a = 1000;
            a.toExponential()
            //rateGauges[YEAR_CO2_USAGE].setValue($NumberFormat(Math.floor(TotalCO2 * 100) / 100));
            rateGauges[YEAR_CO2_USAGE].setValue(Math.round(TotalCO2 * 100) / 100);
        });
    }

    function getCircularChartValueFunc(gaugeDataOption) {
        return function(dataArray) {
            if (_.isEmpty(dataArray)) return;

            var value = dataArray[0].Value;
            gaugeDataOption.gauge().value(value / gaugeDataOption.max * 100);
            gaugeDataOption.value(value); // 파이차트
        };
    }

    function refreshList() {
        //dataSource.pageIndex(0);
        //dataSource.load();
    }


    var viewModel = $.extend(BWA.CommonView.create(
        params, viewInfo, null, null, handleViewShown), {

            refreshList: refreshList,
            viewShowing: handleViewShowing,
            viewShown: handleViewShown,
            viewHidden: handleViewHidden,
            viewDisposing: handleViewDisposing,
        });

    pieDataSource.subscribe(function(array) {
        var chart = $('#energyUsageRatioPieChart').dxPieChart('instance');
        if (chart) {

            chart.option('dataSource', array);
        }
    });

    fuelTypeId.subscribe(function(fuelTypeId) {

        if (initialized === false) return;

        load();
        /*
        setupRateGaugeByFuelType(fuelTypeId);

        setupTodayEnergyUsageStatusSeries();
        setupMonthEnergyUsageStatusSeries();
        loadTodayEnergyUsage(fuelTypeId);
        loadMonthEnergyUsage(fuelTypeId);*/
        
    });

    function setupRateGaugeByFuelType(fuelTypeId) {

        var todayMax = 0;
        var todayCo2Max = 0;
        var thisMonthMax = 0;
        var thisMonthCo2Max = 0;
        var thisYearMax = 0;
        var thisYearCo2Max = 0;
        var unit;
        var yearValue;
//        return;
        switch(fuelTypeId) {
            case FuelType.ELECTRICITY:

                unit = '(kWh)';

                todayMax = ELECTRICITY_DAY_MAX;
                thisMonthMax = ELECTRICITY_MONTH_MAX;
                thisYearMax = ELECTRICITY_YEAR_MAX;

                //todayCo2Max = factorCo2.calculate(ELECTRICITY_DAY_MAX, FuelType.ELECTRICITY);
                //thisMonthCo2Max = factorCo2.calculate(ELECTRICITY_MONTH_MAX, FuelType.ELECTRICITY);
                //thisYearCo2Max = factorCo2.calculate(ELECTRICITY_YEAR_MAX, FuelType.ELECTRICITY) + 8000;
                
                todayCo2Max = factorCo2.calculate(ELECTRICITY_DAY_MAX, FuelType.ELECTRICITY) + factorCo2.calculate(GAS_DAY_MAX, FuelType.GAS)
                + factorCo2.calculate(WATER_DAY_MAX, FuelType.WATER);
                thisMonthCo2Max = factorCo2.calculate(ELECTRICITY_MONTH_MAX, FuelType.ELECTRICITY) + factorCo2.calculate(GAS_MONTH_MAX, FuelType.GAS)
                + factorCo2.calculate(WATER_MONTH_MAX, FuelType.WATER);
                thisYearCo2Max = factorCo2.calculate(ELECTRICITY_YEAR_MAX, FuelType.ELECTRICITY) + factorCo2.calculate(GAS_YEAR_MAX, FuelType.GAS) + factorCo2.calculate(WATER_YEAR_MAX, FuelType.WATER);

                yearValue = yearElectricityUsageValue();
                gaugeDataOptions[FT.ELECTRICITY].max = ELECTRICITY_YEAR_MAX;
                gaugeDataOptions[FT.ELECTRICITY].value = yearElectricityUsageValue;

                break;

            case FuelType.GAS:

                //unit = '(㎥/h)';
                unit = '(㎥)';

                todayMax = GAS_DAY_MAX;
                thisMonthMax = GAS_MONTH_MAX;
                thisYearMax = GAS_YEAR_MAX;

                //todayCo2Max = factorCo2.calculate(GAS_DAY_MAX, FuelType.GAS);
                //thisMonthCo2Max = factorCo2.calculate(GAS_MONTH_MAX, FuelType.GAS);
                //thisYearCo2Max = factorCo2.calculate(GAS_YEAR_MAX, FuelType.GAS) + 2000;
                todayCo2Max = factorCo2.calculate(ELECTRICITY_DAY_MAX, FuelType.ELECTRICITY) + factorCo2.calculate(GAS_DAY_MAX, FuelType.GAS)
                + factorCo2.calculate(WATER_DAY_MAX, FuelType.WATER);
                thisMonthCo2Max = factorCo2.calculate(ELECTRICITY_MONTH_MAX, FuelType.ELECTRICITY) + factorCo2.calculate(GAS_MONTH_MAX, FuelType.GAS)
                + factorCo2.calculate(WATER_MONTH_MAX, FuelType.WATER);
                thisYearCo2Max = factorCo2.calculate(ELECTRICITY_YEAR_MAX, FuelType.ELECTRICITY) + factorCo2.calculate(GAS_YEAR_MAX, FuelType.GAS) + factorCo2.calculate(WATER_YEAR_MAX, FuelType.WATER); 

                yearValue = yearGasUsageValue();
                gaugeDataOptions[FT.GAS].max = GAS_YEAR_MAX;
                gaugeDataOptions[FT.GAS].value = yearGasUsageValue;

                break;

            case FuelType.WATER:

                unit = '(㎥)';

                todayMax = WATER_DAY_MAX;
                thisMonthMax = WATER_MONTH_MAX;
                thisYearMax = WATER_YEAR_MAX;

                //todayCo2Max = factorCo2.calculate(WATER_DAY_MAX, FuelType.WATER);
                //thisMonthCo2Max = factorCo2.calculate(WATER_MONTH_MAX, FuelType.WATER);
                //thisYearCo2Max = factorCo2.calculate(WATER_YEAR_MAX, FuelType.WATER);

                todayCo2Max = factorCo2.calculate(ELECTRICITY_DAY_MAX, FuelType.ELECTRICITY) + factorCo2.calculate(GAS_DAY_MAX, FuelType.GAS)
                    + factorCo2.calculate(WATER_DAY_MAX, FuelType.WATER);
                thisMonthCo2Max = factorCo2.calculate(ELECTRICITY_MONTH_MAX, FuelType.ELECTRICITY) + factorCo2.calculate(GAS_MONTH_MAX, FuelType.GAS)
                    + factorCo2.calculate(WATER_MONTH_MAX, FuelType.WATER);
                thisYearCo2Max = factorCo2.calculate(ELECTRICITY_YEAR_MAX, FuelType.ELECTRICITY) + factorCo2.calculate(GAS_YEAR_MAX, FuelType.GAS) + factorCo2.calculate(WATER_YEAR_MAX, FuelType.WATER);

                yearValue = yearWaterUsageValue();
                gaugeDataOptions[FT.WATER].max = WATER_YEAR_MAX;
                gaugeDataOptions[FT.WATER].value = yearWaterUsageValue;
                break;
        }

        yearValue = Math.round(yearValue * 100) / 100;

        rateGauges[DAY_ENERGY_USAGE].setUnit(unit);
        //rateGauges[DAY_ENERGY_USAGE].setMaxValue(todayMax + todayMax / 2);
        rateGauges[DAY_ENERGY_USAGE].setMaxValue(todayMax);

        rateGauges[MONTH_ENERGY_USAGE].setUnit(unit);
        //rateGauges[MONTH_ENERGY_USAGE].setMaxValue(thisMonthMax + thisMonthMax / 2);
        rateGauges[MONTH_ENERGY_USAGE].setMaxValue(thisMonthMax);

        rateGauges[YEAR_ENERGY_USAGE].setUnit(unit);
        //rateGauges[YEAR_ENERGY_USAGE].setMaxValue(thisYearMax + thisYearMax / 2);
        rateGauges[YEAR_ENERGY_USAGE].setMaxValue(thisYearMax);
        // 2016 10 17 hcLee

        /*if (fuelTypeId >= FuelType.WATER)
            //rateGauges[YEAR_ENERGY_USAGE].setMaxValue(yearValue * 150);
            rateGauges[YEAR_ENERGY_USAGE].setMaxValue(yearValue);*/

        rateGauges[YEAR_ENERGY_USAGE].setValue(yearValue);
/*
        rateGauges[DAY_CO2_USAGE].setMaxValue(todayCo2Max + todayCo2Max / 2);
        rateGauges[MONTH_CO2_USAGE].setMaxValue(thisMonthCo2Max + thisMonthCo2Max / 2);
        rateGauges[YEAR_CO2_USAGE].setMaxValue(thisYearCo2Max + thisMonthCo2Max / 2);*/

        rateGauges[DAY_CO2_USAGE].setMaxValue(todayCo2Max);
        rateGauges[MONTH_CO2_USAGE].setMaxValue(thisMonthCo2Max);
        rateGauges[YEAR_CO2_USAGE].setMaxValue(thisYearCo2Max);

    }

    function setupTodayEnergyUsageStatusSeries() {
        var series = chartOption.getTodayEnergyUsageStatusSeriesOptions({
            today: todayCheck(),
            yesterday: yesterdayCheck(),
            lastWeek: lastWeekCheck()
        });
        dayEnergyUsageChart().option('series', series);
    }


    function setupMonthEnergyUsageStatusSeries() {
        var series = chartOption.getMonthEnergyUsageStatusSeriesOptions({
            thisMonth: thisMonthCheck(),
            lastMonth: lastMonthCheck(),
            lastYear: lastYearCheck()
        });
        monthEnergyUsageChart().option('series', series);
    }

    function getFuelTypeUnit(fuelTypeId) {
        switch (fuelTypeId) {
            case FuelType.ELECTRICITY:
                return 'kWh';
                
            case FuelType.GAS:
                return '㎥';

            case FuelType.WATER:
                return '㎥';
        }
        return '';
    }

    function setValueFromSumFunc(koValue, handleValue) {
        return function(array) {
            var value = _.reduce(array, function(sum, item) {
                return sum + item.Value;
            }, 0);

            if (_.isFunction(handleValue)) {
                handleValue(value);
            }
            koValue(BWA.DataUtil.getNumberStringWithComma(Math.round(value)) + ' ' + getFuelTypeUnit(fuelTypeId()));
        };
    }

    function setEnergyUsageCo2ValueFunc(energyGaugeId, co2GaugeId) {
    }

    todayCheck.subscribe(setupTodayEnergyUsageStatusSeries);
    yesterdayCheck.subscribe(setupTodayEnergyUsageStatusSeries);
    lastWeekCheck.subscribe(setupTodayEnergyUsageStatusSeries);

    thisMonthCheck.subscribe(setupMonthEnergyUsageStatusSeries);
    lastMonthCheck.subscribe(setupMonthEnergyUsageStatusSeries);
    lastYearCheck.subscribe(setupMonthEnergyUsageStatusSeries);


    todayEnergyStatusArray.subscribe(setValueFromSumFunc(todayValue, function(value) {
        //value = Math.round(value);

        // 2016 10 17 수도 이상은 목표값이 없으므로 현재값에서 넉넉하게 150배 하여 MAX를 설정한다 hcLee
/*        if (fuelTypeId() >= FuelType.WATER)
            rateGauges[DAY_ENERGY_USAGE].setMaxValue(value);*/

        value = Math.round(value * 100) / 100;
        rateGauges[DAY_ENERGY_USAGE].setValue(value);
        //rateGauges[DAY_ENERGY_USAGE].setValue(value);  hcLee 2016 03 18
    }));

    yesterdayEnergyStatusArray.subscribe(setValueFromSumFunc(yesterdayValue));
    lastWeekEnergyStatusArray.subscribe(setValueFromSumFunc(lastWeekValue));

    thisMonthEnergyStatusArray.subscribe(setValueFromSumFunc(thisMonthValue, function (value) {

        // 2016 10 17 수도 이상은 목표값이 없으므로 현재값에서 넉넉하게 150배 하여 MAX를 설정한다 hcLee
/*        if (fuelTypeId() >= FuelType.WATER)
            rateGauges[MONTH_ENERGY_USAGE].setMaxValue(value);*/

        //value = Math.round(value);
        value = Math.round(value * 100) / 100;
        rateGauges[MONTH_ENERGY_USAGE].setValue(value);


        //rateGauges[MONTH_CO2_USAGE].setValue(factorCo2.calculate(value, fuelTypeId()));
    }));
    lastMonthEnergyStatusArray.subscribe(setValueFromSumFunc(lastMonthValue));
    lastYearEnergyStatusArray.subscribe(setValueFromSumFunc(lastYearValue));


    viewModel.todayCheck = todayCheck;
    viewModel.yesterdayCheck = yesterdayCheck;
    viewModel.lastWeekCheck = lastWeekCheck;
    viewModel.thisMonthCheck = thisMonthCheck;
    viewModel.lastMonthCheck = lastMonthCheck;
    viewModel.lastYearCheck = lastYearCheck;

    viewModel.todayValue = todayValue;
    viewModel.yesterdayValue = yesterdayValue;
    viewModel.lastWeekValue = lastWeekValue;
    viewModel.thisMonthValue = thisMonthValue;
    viewModel.lastMonthValue = lastMonthValue;
    viewModel.lastYearValue = lastYearValue;

    viewModel.fuelTypes = fuelTypes;
    viewModel.fuelTypeId = fuelTypeId;

    viewModel.currentTemp = currentTemp;
    viewModel.currentHumi = currentHumi;

    return viewModel;
};