/**
 * Views/Partial/LCA/Waste.cshtml is using this controller
 */

var arr = window.location.href.split("/");
if (arr[3].indexOf('app') == 0)
    baseUrl = '';
else
    baseUrl = '/' + arr[3];

angular.module('CarbonFootprint')
    .controller('LCAWasteCtrl', ['$scope', '$http', '$routeParams', 'ParameterCacheService', 'JoinSurveyItemAndParameter', '$q', 'MultiLanguageService', 'ExportCsvService', 
        function ($scope, $http, $routeParams, ParameterCacheService, JoinService, $q, MultiLanguageService, ExportCsvService) {

            // Multi-language resource object 
            var resource;
            var options;

            // This property controlls modal form , will be passed to table-edit-modal directive
            $scope.modalFormOption = {};
            $scope.model = [];
            $scope.sumKgCO2e = 0;

            $scope.createProcess = function () {

                // Create an object & select it
                var toBeCreated = {};
                toBeCreated.ID = 0;
                toBeCreated.LCAID = $routeParams.LCAID;

                // Set waste type (other)
                toBeCreated.Type = 1;

                // For modal form
                $scope.selectRow.toBeEdit = toBeCreated;
                $scope.modalFormOption.show = true;
                $scope.dataQualityOption = {};
                $scope.dataQualityOption.data = {};
                $scope.isEdit = false;

                // set $scope.baseUrl
                var baseUrl = $scope.baseUrl;
                if (typeof (baseUrl) === 'undefined' || baseUrl == null) {
                    var arr = window.location.href.split("/");
                    if (arr[3].indexOf('app') == 0)
                        baseUrl = '';
                    else
                        baseUrl = '/' + arr[3];
                    $scope.baseUrl = baseUrl;
                }

                $scope.save = function () {
                    
                    // Calculate KgCO2e
                    JoinService.joinAsync([toBeCreated]).then(function () {
                        if (toBeCreated.Unit == undefined) {
                            confirm('無法判斷該係數單位');
                        }
                        else if (toBeCreated.Unit.indexOf('公斤') > -1 || toBeCreated.Unit.indexOf('kg') > -1) { }
                        else if (toBeCreated.Unit.indexOf('公噸') > -1 || toBeCreated.Unit.indexOf('mt') > -1) {
                            toBeCreated.Unit = '公斤(kg)';
                            toBeCreated.ParameterValue = toBeCreated.ParameterValue / 1000;
                        }
                        else {
                            confirm('無法判斷\'' + toBeCreated.Unit + '\'該單位');
                        }

                        // Update KgCO2e property 
                        setKgCO2e([toBeCreated]);
                        $http.post($scope.baseUrl+'/api/Waste/Save/' + toBeCreated.LCAID + '/' + toBeCreated.ID, toBeCreated)
                            .success(function (data) {

                                // Join WasteCategory and ProcessingPattern data into model
                                data.WasteCategory = getWasteCategory(options[toBeCreated.ParameterID]);
                                data.ProcessingPattern = getProcessingPattern(options[toBeCreated.ParameterID]);

                                $scope.model.unshift(data);
                                $scope.modalFormOption.show = false;
                                calcTotalKgCO2e();

                            })
                            .error(function (error) {
                                console.log(error);
                            });
                    });
                };
            };

            $scope.editProcess = function (selected) {
                var toBeEdit = $scope.selectRow.toBeEdit = angular.copy(selected);

                // Reset processing pattern dropdown list options
                $scope.processingPatterns = [];

                angular.forEach(options, function (value, key) {
                    if (value.search(toBeEdit.WasteCategory) !== -1 && toBeEdit.WasteCategory) {
                        var processingPattern = getProcessingPattern(value);
                        $scope.processingPatterns[key] = processingPattern;
                    }
                });

                $scope.processingPatterns = filterDuplicatedData($scope.processingPatterns);

                $scope.modalFormOption.show = true;
                $scope.dataQualityOption = {};
                $scope.dataQualityOption.data = {};
                $scope.isEdit = true;

                $scope.save = function () {
                    JoinService.joinAsync([toBeEdit]).then(function () {
                        if (toBeEdit.Unit == undefined) {
                            confirm('無法判斷該係數單位');
                        }
                        else if (toBeEdit.Unit.indexOf('公斤') > -1 || toBeEdit.Unit.indexOf('kg') > -1) { }
                        else if(toBeEdit.Unit.indexOf('公噸') > -1 || toBeEdit.Unit.indexOf('mt') > -1) {
                            toBeEdit.Unit = '公斤(kg)';
                            toBeEdit.ParameterValue = toBeEdit.ParameterValue / 1000;
                        }
                        else {
                            confirm('無法判斷\'' + toBeEdit.Unit + '\'該係數單位');
                        }
                        // Update KgCO2e property 
                        setKgCO2e([toBeEdit]);
                        //toBeEdit.KgCO2e = toBeEdit.Scalar * toBeEdit.ParameterValue;
                        $http.post($scope.baseUrl+'/api/Waste/Save/' + toBeEdit.LCAID + '/' + toBeEdit.ID, toBeEdit)
                            .success(function (data) {

                                // Update waste data
                                toBeEdit.WasteCategory = getWasteCategory(options[toBeEdit.ParameterID]);
                                toBeEdit.ProcessingPattern = getProcessingPattern(options[toBeEdit.ParameterID]);

                                angular.copy(toBeEdit, selected);
                                $scope.modalFormOption.show = false;
                                calcTotalKgCO2e();
                            })
                            .error(function (error) {
                                console.log(error);
                            });
                    });
                };
            };

            $scope.dataQualityShow = function (selected) {
                $http.get($scope.baseUrl+'/api/DataQualityLevel/GetByTableId/ProductLCAFabSurveyForm_Wastes/' + selected.ID
                ).success(function (data) {
                    angular.copy(data, $scope.dataQualityOption.data);
                    $scope.dataQualityOption.data.Name = selected.ParameterDescription;
                    $scope.dataQualityOption.data.LCAID = selected.LCAID;
                    //todo !!... load pre saved data
                    //$scope.dataQualityOption.Fi = 0.0123;//test only;
                    //todo !!... 還需要總碳排量才能算出 碳排量佔比
                    $scope.dataQualityOption.showSaveBtn = $scope.lcaDetail.Status == 1;
                    $scope.dataQualityOption.show = true;
                }).error(function (data, status) {
                    alert(data.ExceptionMessage);
                });
            };

            $scope.deleteProcess = function (selected) {
                var isConfirm = confirm(resource.DeleteItemMsg);

                if (isConfirm) {
                    $http.delete($scope.baseUrl+'/api/Waste/Delete/' + selected.ID)
                        .success(function () {
                            var index = $scope.model.indexOf(selected);
                            $scope.model.splice(index, 1);

                            // This operate is base on selectRow directive in TableEdit.js file
                            $scope.selectRow.unSelect();
                            calcTotalKgCO2e();

                        })
                        .error(function (error) {
                            console.log(error);
                        });
                }
            };

            $scope.selectSimaproProcess = function (selected, isOutside = true) {
                $scope.simaproOption = {};
                $scope.simaproOption.show = true;
                $scope.simaproOption.filter = 1; // SimaproOption.Waste 廢棄物
                $scope.simaproOption.onOk = function (selectedParameter, selectedCategory) {
                    console.log('simaproOption.onOk', selectedParameter, selectedCategory);
                    selected.ParameterID = selectedParameter.ID;
                    selected.ParameterTypeID = selectedCategory.ID;
                    selected.ParameterValue = selectedParameter.Value
                    selected.ParameterDescription =
                        selectedParameter.DisplayNameTW + ': ' + selectedParameter.Remark;
                    selected.Unit = selectedParameter.Unit;
                    selected.localDisplayParameterValue = selectedParameter.Value;
                    selected.ParameterSource = selectedParameter.Description;// 2;
                    selected.Description = selectedCategory.DisplayNameTW;
                    if (isOutside) {
                        LCADetailCacheService.updateMaterialsAsync([selected]);
                    }
                    $scope.updateKgCO2e(selected);
                    //LCADetailCacheService.updateMaterialsAsync([selected]);
                }
            };

            $scope.updateKgCO2e = function (selected) {
                selected.KgCO2e = selected.Scalar * selected.ParameterValue;
            }

            /* modelBuilder for create & export */
            /** Caution!: The 'ParameterID' property depends on 'options'.
                          This modelBuilder is binded with this controller.
                          Refactoring modelBuilder.create() with more arugments will be better **/
            $scope.modelBuilder = {
                create: function (data, LCAID) {
                    try {
                        var ProcessType;
                        var ProcessTypeName = data[1];
                        if (ProcessTypeName == resource['Incineration']) {
                            ProcessType = 0;
                        } else if (ProcessTypeName == resource['Burial']) {
                            ProcessType = 1;
                        } else if (ProcessTypeName == resource['Recycling']) {
                            ProcessType = 2;
                        }
                        // get DQIID by DQIName
                        var DQIID;
                        var DQIName = data[7];
                        if (DQIName == resource['MetaDataDQI1']) {
                            DQIID = 0;
                        } else if (DQIName == resource['MetaDataDQI2']) {
                            DQIID = 1;
                        } else if (DQIName == resource['MetaDataDQI3']) {
                            DQIID = 2;
                        }

                        var model = {
                            Name: data[0],
                            ProcessType: ProcessType,
                            Scalar: parseFloat(data[2]) ? data[2] : 0,
                            ParameterValue: parseFloat(data[3]) ? data[3] : 0,
                            Unit: data[4],
                            ParameterDescription: data[5],
                            ParameterSource: data[6],
                            DQI: DQIID,
                            Description: data[7],
                            Type: 1, // Set waste type (other)
                            LCAID: LCAID
                        };

                        // check imported data length and model length (-1 for LCAID, -1 for Type)
                        if (data.length !== getObjectSize(model) - 2) {
                            throw resource['EXCELFileFormatWrong'];
                        }

                        if (model.Name === '' || model.Name === undefined) {
                            throw resource['WasteName'] + resource['RequiredMessage'];
                        }

                        if (model.Scalar === '' || model.Scalar === undefined) {
                            throw resource['WasteOtherScalar'] + resource['RequiredMessage'];
                        }

                        if (model.ParameterValue === '' || model.ParameterValue === undefined) {
                            throw resource['Parameter'] + resource['RequiredMessage'];
                        }

                        // if find incorrect DQI
                        if (model.ProcessType === undefined) {
                            throw resource['MataDataDQI'] + resource['ErrorText'] + '\'' + resource['MetaDataDQI1'] + '\',\'' + resource['MetaDataDQI2'] + '\',\'' + resource['MetaDataDQI3'] + '\'';
                        }

                        // if find incorrect DQI
                        if (model.DQI === undefined) {
                            throw resource['ProcessType'] + resource['ErrorText'] + '\'' + resource['Incineration'] + '\',\'' + resource['Burial'] + '\',\'' + resource['Recycling'] + '\'';
                        }

                        // if find incorrect ParameterID
                        //if (model.ParameterID === undefined) {
                        //    throw resource['WasteCategory'] + '/' + resource['ProcessingPatterns'] + ' Error';
                        //}

                        return model;
                    }
                    catch (err) {
                        return { error: err };
                    }

                },
                export: function (list, exportType = 'txt') {
                    if (exportType == 'csv') {
                        var data = [];

                        // header
                        data.push([
                            resource['WasteName'],
                            resource['ProcessType'],
                            resource['WasteOtherScalar'],
                            resource['Parameter'],
                            resource['ParameterUnit'],
                            resource['ParaDesc'],
                            resource['Parameter'] + resource['Source'],
                            resource['MataDataDQI'],
                            resource['Notes']
                        ]);

                        // body
                        angular.forEach(list, function (entry) {
                            var csv = [];
                            //column 1
                            csv.push(entry.Name);
                            //column 2
                            if (entry.ProcessType == 0) {
                                csv.push(resource['Incineration']);
                            } else if (entry.ProcessType == 1) {
                                csv.push(resource['Burial']);
                            } else if (entry.ProcessType == 2) {
                                csv.push(resource['Recycling']);
                            }
                            //column 3
                            csv.push(entry.Scalar);
                            //column 4
                            csv.push(entry.ParameterValue);
                            //column 5
                            csv.push(entry.Unit);
                            //column 6
                            csv.push(entry.ParameterDescription);
                            //column 7
                            csv.push(entry.ParameterSource);
                            //column 8
                            if (entry.DQI == 0) {
                                csv.push(resource['MetaDataDQI1']);
                            } else if (entry.DQI == 1) {
                                csv.push(resource['MetaDataDQI2']);
                            } else if (entry.DQI == 2) {
                                csv.push(resource['MetaDataDQI3']);
                            }
                            //column 9
                            csv.push(entry.Description);

                            data.push(csv);
                        });
                        ExportCsvService.startExport(data, "Export_Waste.csv");
                    }
                    else {
                        var csv = '\uFEFF';
                        var link;
                        var delimeter = '\t';

                        // header
                        csv += resource['WasteCategory'] + delimeter
                            + resource['ProcessingPatterns'] + delimeter
                            + resource['WasteOtherScalar'] + delimeter
                            + resource['MataDataDQI'] + delimeter
                            + resource['DQIDescription'] + delimeter
                            + resource['Notes'];

                        // body
                        angular.forEach(list, function (entry) {
                            csv += '\r\n';
                            //column 1
                            csv += entry.WasteCategory + delimeter;
                            //column 2
                            csv += entry.ProcessingPattern + delimeter;
                            //column 2
                            csv += entry.Scalar + delimeter;
                            //column 3
                            if (entry.DQI == 0) {
                                csv += resource['MetaDataDQI1'] + delimeter
                            } else if (entry.DQI == 1) {
                                csv += resource['MetaDataDQI2'] + delimeter
                            } else if (entry.DQI == 2) {
                                csv += resource['MetaDataDQI3'] + delimeter
                            }
                            //column 4
                            csv += entry.DQIDescription + delimeter;
                            //column 5
                            csv += entry.Description;
                        });
                        var filename = "Export_Waste.txt";
                        require([baseUrl+'/Scripts/FileSaver.js'],
                            function requrieSuccess(SaveAs) {
                                var textFileAsBlob = new Blob([csv], { type: 'text;charset=utf-8,' });
                                saveAs(textFileAsBlob, "Export_Waste.txt")
                            },
                            function requireError(error) {
                            }
                        );

                    }
                }
            };

            /* file import options & modal control */
            $scope.fileImportOptions = {
                modelBuilder: $scope.modelBuilder,
                saveAsync: batchCreateAndUpdateCache
            };

            $scope.fileImportModal = {
                show: false
            };

            /* quote options & modal control */
            $scope.quoteOptions = {
                queryDataAsyncFn: function (LCAID) {
                    var deferred = $q.defer();
                    getAllDataAsync(LCAID).then(function (data) {
                        deferred.resolve(data.Wastes.filter(x => x.Type == 1));
                    })
                    return deferred.promise;
                },
                saveAsyncFn: batchCreateAndUpdateCache
            };

            $scope.quoteModal = {
                show: false
            };

            // Get data and prepare $scope.model
            getAllDataAsync($routeParams.LCAID)
                .then(function (response) {
                    options = response.OptionsTwo;
                    var sheetHeader = response.SheetHeader ? response.SheetHeader : {};

                    if (response.Wastes) {
                        $scope.model = response.Wastes.filter(x => x.Type == 1);
                    }

                    // Get each model's CasteCategory and ProcessingPattern by "ParameterID"
                    angular.forEach($scope.model, function (model) {
                        model.WasteCategory = getWasteCategory(options[model.ParameterID]);
                        model.ProcessingPattern = getProcessingPattern(options[model.ParameterID]);
                    });

                    // Sources of dropdown list
                    $scope.wasteCategories = [];

                    angular.forEach(options, function (value) {
                        var wasteCategory = getWasteCategory(value);
                        $scope.wasteCategories.push(wasteCategory);
                    });
                    calcTotalKgCO2e();

                    // Duplicated wasteCategories
                    $scope.wasteCategories = filterDuplicatedData($scope.wasteCategories);

                    // $scope.sheetHeader is parent's object
                    $scope.sheetHeader.SheetFillerName = sheetHeader.SheetFillerName;
                    $scope.sheetHeader.Phone = sheetHeader.Phone;
                    $scope.sheetHeader.Department = sheetHeader.Department;

                }, function (error) {
                    console.log(error);
                });


            // Get multilanguage resource
            MultiLanguageService.getResourceAsync()
                .then(function (response) {
                    resource = response;
                }, function (error) {
                    console.log(error);
                });

            /**
             * Private function: save all async
             * @param  {[Array]} : array of parsed objects
             * @return {[promise]}
             */
            function batchCreateAndUpdateCache(parsedList) {
                var deferred = $q.defer();
                
                // Calculate KgCO2e and sava all
                JoinService.joinAsync(parsedList)
                    .then(function () {
                        // update KgCO2e properties 
                        setKgCO2e(parsedList);

                        $http.post($scope.baseUrl+'/api/Waste/SaveAll/', parsedList)
                            .success(function (data) {
                                // close modals
                                $scope.fileImportModal.show = false;
                                $scope.quoteModal.show = false;

                                // Update waste data
                                angular.forEach(data.result, function (model) {
                                    model.WasteCategory = getWasteCategory(options[model.ParameterID]);
                                    model.ProcessingPattern = getProcessingPattern(options[model.ParameterID]);
                                });

                                // concat created data and $scope.model
                                $scope.model = data.result.concat($scope.model);

                                deferred.resolve(data);
                                calcTotalKgCO2e();

                            })
                            .error(function (e) {
                                console.log(e.Message);
                            });
                    });
                return deferred.promise;
            }

            /**
             * Update the KgCO2e property of the model objects
             * @param {[Array]} : array of model objects 
             */
            function setKgCO2e(models) {
                angular.forEach(models, function (entry) {
                    //console.log('setKgCO2e',entry);
                     // Join parameter value and calculate KgCO2e
                    if (entry.ParameterValue && entry.Scalar) {
                        entry.KgCO2e = entry.ParameterValue * entry.Scalar;
                    }
                    else
                        entry.KgCO2e = 0;
                });
            }

            /* Private function: get all list data from server */
            function getAllDataAsync(LCAID) {
                var deferred = $q.defer();
                $http.get($scope.baseUrl+'/api/Waste/GetByLcaId/' + LCAID)
                    .success(function (data) {
                        deferred.resolve(data);
                    })
                    .error(function () {
                        deferred.resolve(null);
                    });
                return deferred.promise;
            }

            $scope.$watch('selectRow.toBeEdit.WasteCategory', function (wasteCategory) {

                // If wasteCategory is changed then reset processingPatterns
                $scope.processingPatterns = [];

                angular.forEach(options, function (value, key) {
                    if (value.search(wasteCategory) !== -1 && wasteCategory) {
                        var processingPattern = getProcessingPattern(value);
                        $scope.processingPatterns[key] = processingPattern;
                    }
                });
            });

            // Update model parameter id
            $scope.$watch('selectRow.toBeEdit.ProcessingPattern', function () {
                var toBeEdit = $scope.selectRow.toBeEdit;

                angular.forEach(options, function (value, key) {
                    if (value.search(toBeEdit.WasteCategory) !== -1 &&
                        value.search(toBeEdit.ProcessingPattern) !== -1 &&
                        toBeEdit.WasteCategory && toBeEdit.ProcessingPattern) {
                        toBeEdit.ParameterID = key;
                    }
                });
            });

            /**
             * Get substring "wasteCategory" from a string
             * @param String
             * @returns String
             */
            function getWasteCategory(value) {
                return angular.isString(value) ? value.slice(0, value.indexOf(',')) : null;
            }

            /**
             * Get substring "processingPattern" from a string
             * @param String
             * @returns String
             */
            function getProcessingPattern(value) {
                return angular.isString(value) ? value.slice(value.indexOf(',') + 1, value.length) : null;
            }

            /** 
             * Remove identical element from the array
             * @parem Array
             * @returns Array
             */
            function filterDuplicatedData(array) {
                var filteredArray = [];

                angular.forEach(array, function (value) {
                    if ($.inArray(value, filteredArray) === -1) {
                        filteredArray.push(value);
                    }
                });

                return filteredArray;
            }

            function calcTotalKgCO2e() {
                $scope.summary = Enumerable.From($scope.model).Where('$.Type == 1').GroupBy("$.Name", "$.KgCO2e", function (key, group) {
                    return { Name: key, totalKgCO2e: Enumerable.From(group).Sum(), AllocationKgCO2e: Enumerable.From(group).Sum() * $scope.Ratio };
                }).ToArray();
                var sumKgCO2e = 0;
                angular.forEach($scope.summary, function (item) {
                    sumKgCO2e += item.totalKgCO2e;
                });
                $scope.sumKgCO2e = sumKgCO2e;
            }

            $scope.onAllocationChange = function (Allocation) {
                $scope.Allocation = Allocation
                if ($scope.Allocation == 0) //重量分配
                    //$scope.Ratio = $scope.calculate($scope.lcaDetail.ProductProductionPcs, $scope.product.Weight, $scope.lcaDetail.FabProductionWeight);
                    $scope.Ratio = $scope.calculate($scope.lcaDetail.ProductProductionPcs * $scope.product.Weight / $scope.lcaDetail.FabProductionWeight, 1, $scope.lcaDetail.ProductProductionPcs);
                else if ($scope.Allocation == 1) //面積分配
                    //$scope.Ratio = $scope.calculate($scope.lcaDetail.ProductProductionPcs, $scope.product.AreaSize, $scope.lcaDetail.FabProductionArea);
                    $scope.Ratio = $scope.calculate($scope.lcaDetail.ProductProductionPcs * $scope.product.AreaSize / $scope.lcaDetail.FabProductionArea, 1, $scope.lcaDetail.ProductProductionPcs);
                else if ($scope.Allocation == 2) //產量分配
                    //$scope.Ratio = $scope.calculate($scope.lcaDetail.ProductProductionPcs, 1, $scope.lcaDetail.FabProductionPcs);
                    $scope.Ratio = $scope.calculate($scope.lcaDetail.ProductProductionPcs, 1, $scope.lcaDetail.FabProductionPcs);
                else if ($scope.Allocation == 3) //經濟分配
                    //$scope.Ratio = $scope.calculate($scope.lcaDetail.ProductProductionPcs, $scope.lcaDetail.ProductProductionEconomic, $scope.lcaDetail.FabProductionEconomic);
                    $scope.Ratio = $scope.calculate($scope.lcaDetail.ProductProductionPcs * $scope.lcaDetail.ProductProductionEconomic / $scope.lcaDetail.FabProductionEconomic, 1, $scope.lcaDetail.ProductProductionPcs);
                else if ($scope.Allocation == 4) //工時分配
                    //$scope.Ratio = $scope.calculate($scope.lcaDetail.ProductProductionPcs, $scope.lcaDetail.ProductProductionHour, $scope.lcaDetail.FabProductionHour);
                    $scope.Ratio = $scope.calculate($scope.lcaDetail.ProductProductionPcs * $scope.lcaDetail.ProductProductionHour / $scope.lcaDetail.FabProductionHour, 1, $scope.lcaDetail.ProductProductionPcs);
                else if ($scope.Allocation == 99)
                    $scope.Ratio = 1;

                $http.post($scope.baseUrl+'/api/LCA/SaveAllocation/' + $routeParams.LCAID + '/' + $routeParams.DetailType + '/' + $scope.Allocation)
                    .success(function (data) {
                        calcTotalKgCO2e();
                        $scope.modifyCacheAllocation();
                    })
            }

        }]);