/**
 * Created by wisestone on 2018-01-03.
 */
'use strict';

define([
        'app',
        'angular'
    ],
    function (app, angular) {
        app.controller('issueDetailController', ['$scope', '$rootScope', '$log', '$resourceProvider', '$tableProvider', '$state', '$uibModal', 'SweetAlert', '$timeout', 'Issue', 'IssueComment', 'IssueRelation', 'AttachedFile', 'IssueStatus', '$filter',
            function ($scope, $rootScope, $log, $resourceProvider, $tableProvider, $state, $uibModal, SweetAlert, $timeout, Issue, IssueComment, IssueRelation, AttachedFile, IssueStatus, $filter) {

                //  IssueListController vm, fn 변수 상속.

                $scope.fn.getIssueDetail = getIssueDetail;  //  이슈 상세 정보 가져오기
                $scope.fn.addComment = addComment;  //  댓글 등록
                $scope.fn.removeComment = removeComment;    //  댓글 삭제
                $scope.fn.getCommentList = getCommentList;  //  댓글 목록 가져오기
                $scope.fn.getAttachedFiles = getAttachedFiles;  //  첨부 파일 목록
                $scope.fn.makePreviewImages = makePreviewImages;    //  이슈 이미지 미리보기 만들기
                $scope.fn.makeActiveHistory = makeActiveHistory;    //  활동 이력 만들기
                $scope.fn.setFormByIssueTypeCustomFields = setFormByIssueTypeCustomFields;  //  이슈 유형에 연결된 사용자 정의 필드 정보를 입력 폼에서 사용할 수 있게 가공한다.
                $scope.fn.setUseValueByIssueTypeCustomFields = setUseValueByIssueTypeCustomFields;  //  이슈에서 사용자가 선택한 사용자 정의 필드 값을 입력 폼에 셋팅한다.
                $scope.fn.updateActiveHistory = updateActiveHistory;    //  활동 내역에서 전체 보기 탭을 눌렀을 때 댓글, 기록 정보를 업데이트 한다.
                $scope.fn.getChangeIssueStatusList = getChangeIssueStatusList;    //  이슈의 현재 상태에서 변경 가능한 이슈 샅태 목록 가져오기
                $scope.fn.modifyIssueStatus = modifyIssueStatus;    //  이슈 상태 변경
                $scope.fn.modifyIssueUser = modifyIssueUser;    //  이슈 담당자 변경
                $scope.fn.initReload = initReload;  //  초기화 해야할 할목을 지정하여 다른 이슈를 클릭할 때 초기화해준다.
                $scope.fn.sendMail = sendMail;  //  특정 사용자에게 이슈 정보를 메일로 발송
                $scope.fn.versionView = versionView;    //  버전 정보를 표시한다.
                $scope.fn.reservation = reservation;    //  예약 정보를 확인 및 변경 한다.
                $scope.fn.getIssueListCallBack = getIssueListCallBack;
                $scope.fn.addRelationIssue = addRelationIssue;      // 연관 이슈 추가


                //  이슈 목록 컨트롤러 vm, fn 상속 중
                $scope.vm.viewer = {};
                $scope.vm.images = [];  //  첨부된 파일 중 이미지 파일
                $scope.vm.activeTab = "ALL";    //  활동 내역 탭
                //  이슈 상태 변경 표시 여부
                $scope.vm.editor = {
                    issueStatus : false
                };
                //  변경 가능한 이슈 상태 목록
                $scope.vm.issueForm = {
                    issueStatusList : [],
                    issueStatusId : ""
                };

                // 연관 일감 관련
                $scope.vm.relationIssueTypes =
                [
                    { id: 0, name: $filter("translate")("issue.relationIssueType1") },
                    { id: 1, name: $filter("translate")("issue.relationIssueType2") },
                    { id: 2, name: $filter("translate")("issue.relationIssueType3") },
                    { id: 3, name: $filter("translate")("issue.relationIssueType4") },
                    { id: 4, name: $filter("translate")("issue.relationIssueType5") },
                    { id: 5, name: $filter("translate")("issue.relationIssueType6") }
                ];
                $scope.vm.relationIssueType = $scope.vm.relationIssueTypes[0];

                $scope.vm.form = {
                    issues : []
                };

                $scope.vm.issueName = "";
                $scope.vm.autoCompletePage = {
                    issue : {
                        page : 0,
                        totalPage : 0
                    },
                };

                $scope.vm.relResponseData = [];
                $scope.vm.relTableConfigs = [];
                //  테이블 이벤트
                $scope.relTableEvent = {
                    removeRelationIssue : removeRelationIssue,   // 연관 일감 삭제
                    changeDetailView : changeDetailView
                };

                function changeDetailView(issue) {
                    //  이슈 번호를 저장한 후 이슈 목록으로 이동한다.
                    // $rootScope.$broadcast("makeIssueSearch", issue);
                    $scope.$parent.tableEvent.changeDetailView(issue.id);
                }

                // 연관 일감 삭제
                function removeRelationIssue(id) {
                    //  삭제 알림
                    SweetAlert.swal({
                            title : $filter("translate")("issue.relationIssueRemove"), // 연관 일감 삭제
                            text : $filter("translate")("issue.wantToDeleteSelectIssue"),
                            type : "warning",
                            showCancelButton : true,
                            confirmButtonColor : "#DD6B55",
                            confirmButtonText : $filter("translate")("common.delete"), // 삭제
                            cancelButtonText : $filter("translate")("common.cancel"), // 취소
                            closeOnConfirm : false,
                            closeOnCancel : true
                        },
                        function (isConfirm) {
                            SweetAlert.close();

                            if (isConfirm) {
                                $rootScope.spinner = true;

                                var contents = {
                                    id : id
                                };

                                IssueRelation.delete($resourceProvider.getContent(
                                    contents,
                                    $resourceProvider.getPageContent(0, 10))).then(function (result) {

                                    if (result.data.message.status === "success") {
                                        $scope.fn.getIssueDetail();
                                    }
                                    else {
                                        SweetAlert.error($filter("translate")("issue.failedToIssueDeleteIssueRelation"), result.data.message.message); // "연관일감 삭제 실패"
                                    }
                                    $rootScope.spinner = false;
                                });
                            }
                        });


                }

                //  프로젝트 autocomplete page 업데이트
                function getIssueListCallBack(result) {
                    $scope.vm.autoCompletePage.issue.totalPage = result.data.page.totalPage;
                }

                //  이슈 테이블 설정
                function makeTableConfigs() {
                    $scope.vm.relTableConfigs = [];
                    $scope.vm.relTableConfigs.push($tableProvider.config()
                        .setHName("issue.relationIssueType")
                        .setDType("renderer")
                        .setHWidth("width-30 bold")
                        .setHSort(false)
                        .setDRenderer("ISSUE_RELATION_TYPE"))
                    $scope.vm.relTableConfigs.push($tableProvider.config()
                        .setHName("issue.relationIssueTitle")
                        .setDType("renderer")
                        .setHWidth("width-60 bold")
                        .setHSort(false)
                        .setDRenderer("ISSUE_RELATION_MOVE"))
                    $scope.vm.relTableConfigs.push($tableProvider.config()
                        .setHName("issue.relationIssueDelete")
                        .setDType("renderer")
                        .setHWidth("width-10 bold")
                        .setDRenderer("ISSUE_RELATION_DELETE")
                        .setHSort(false)
                        .setDAlign("text-center"))
                }

                // 연관 일감 목록 가져오기
                // function getRelationIssueList() {
                //     var contents = {
                //         issueId : $rootScope.currentDetailIssueId,
                //     };
                //
                //     IssueRelation.find($resourceProvider.getContent(
                //         contents,
                //         $resourceProvider.getPageContent(0, 10))).then(function (result) {
                //
                //         if (result.data.message.status === "success") {
                //             $scope.vm.relResponseData = result.data;
                //         }
                //         else {
                //             SweetAlert.error($filter("translate")("issue.failedToIssueAddIssueRelation"), result.data.message.message); // "연관일감 생성 실패"
                //         }
                //     });
                // }


                // 연관 이슈 추가
                function addRelationIssue() {
                    if ($scope.vm.issueName.length == 0 || $scope.vm.form.issues.length == 0
                    || $scope.vm.issueName != $scope.vm.form.issues[0].title) {
                        SweetAlert.error($filter("translate")("issue.errorSelectRelationIssue"), "");
                        return;
                    }

                    var contents = {
                        relationIssueType : $scope.vm.relationIssueType.id,
                        issueId : $rootScope.currentDetailIssueId,
                        relationIssueId : $scope.vm.form.issues[0].id
                    };

                    IssueRelation.add($resourceProvider.getContent(
                        contents,
                        $resourceProvider.getPageContent(0, 10))).then(function (result) {

                        if (result.data.message.status === "success") {
                            $scope.fn.getIssueDetail();
                        }
                        else {
                            SweetAlert.error($filter("translate")("issue.failedToIssueAddIssueRelation"), result.data.message.message); // "연관일감 생성 실패"
                        }
                    });
                }


                //  이슈명을 클릭하면 이슈 상세 정보를 조회한다.
                $scope.$on("getIssueDetail", function (event, args) {
                    $scope.vm.viewer.id = args["id"];
                    $scope.fn.getIssueDetail();
                });

                //  초기화 해야할 할목을 지정하여 다른 이슈를 클릭할 때 초기화해준다.
                function initReload() {
                    $scope.vm.editor.issueStatus = false;
                    $scope.vm.issueForm.issueStatusList = [];
                    $scope.vm.issueForm.issueStatusId = "";
                    if ($scope.$root.$$phase !== '$apply' && $scope.$root.$$phase !== '$digest') {
                        $scope.$apply();
                    }
                }

                //  이슈 상태 변경
                function modifyIssueStatus() {
                    $uibModal.open({
                        templateUrl : 'views/issue/issueModifyStatus.html',
                        size : "md",
                        controller : 'issueModifyStatusController',
                        backdrop : 'static',
                        resolve : {
                            parameter : function () {
                                return {
                                    issueIds : [$scope.vm.viewer.id]
                                };
                            }
                        }
                    });
                }

                //  담당자 변경
                function modifyIssueUser() {
                    $uibModal.open({
                        templateUrl : 'views/issue/issueModifyUser.html',
                        size : "md",
                        controller : 'issueModifyUserController',
                        backdrop : 'static',
                        resolve : {
                            parameter : function () {
                                return {
                                    userVos : [$scope.vm.form.issues[0].userVos],
                                    id : [$scope.vm.form.issues[0].id],
                                    projectId : [$scope.vm.form.issues[0].projectVo.id],
                                    project : [$scope.vm.form.issues[0].projectVo]
                                };
                            }
                        }
                    });
                }

                //  변경 가능한 이슈 상태 목록을 조회하고 수정 모드로 화면을 변경한다.
                function getChangeIssueStatusList(checkPermission) {
                    //  수정 권한이 없으면 이슈 상태 변경 불가
                    if (!checkPermission) {
                        return;
                    }

                    //  수정 모드로 변경
                    $scope.vm.editor.issueStatus = true;

                    var content = {
                        id : $scope.vm.viewer.issueStatusVo.id,
                        issueTypeId : $scope.vm.viewer.issueTypeVo.id
                    };

                    IssueStatus.findNextIssueStatus($resourceProvider.getContent(
                        content,
                        $resourceProvider.getPageContent(0, 0))).then(function (result) {

                        if (result.data.message.status === "success") {
                            $scope.vm.issueForm.issueStatusList = result.data.data;
                        }
                        else {
                            SweetAlert.swal($filter("translate")("issue.errorRemovableIssueStatusList"), result.data.message.message, "error"); // "이동 가능한 이슈 상태 목록 조회 오류"
                        }
                    });
                }

                //  이슈 상세 정보 조회
                function getIssueDetail() {
                    //  초기화 해야할 할목을 지정하여 다른 이슈를 클릭할 때 초기화해준다.
                    $scope.fn.initReload();

                    Issue.detail($resourceProvider.getContent(
                        {id : $scope.vm.viewer.id, deep : "02"},
                        $resourceProvider.getPageContent(0, 1))).then(function (result) {

                        if (result.data.message.status === "success") {
                            if (angular.isDefined(result.data.data)) {
                                $scope.vm.viewer = angular.copy(result.data.data);
                                //  이슈 이미지 미리 보기 만들기
                                $scope.fn.makePreviewImages(result.data.data.attachedFileVos);
                                //  활동 이력 만들기
                                $scope.fn.makeActiveHistory();

                                $scope.vm.viewer.startDate = result.data.data.startDate == null ? "common.unspecified" : result.data.data.startDate; // 미지정
                                $scope.vm.viewer.completeDate = result.data.data.completeDate == null ? "common.unspecified" : result.data.data.completeDate; // 미지정

                                //  이슈 유형에 연결된 사용자 정의 필드 정보를 입력 폼에서 사용할 수 있게 가공한다.
                                $scope.fn.setFormByIssueTypeCustomFields(result.data.data.issueTypeCustomFieldVos);
                                //  이슈에서 사용자가 선택한 사용자 정의 필드 값을 입력 폼에 셋팅한다.
                                $scope.fn.setUseValueByIssueTypeCustomFields(result.data.data.issueCustomFieldValueVos);


                                // 연관 일감
                                $scope.vm.issueName = "";
                                $scope.vm.form.issues = [];
                                $scope.vm.form.issues.push(result.data.data);

                                makeTableConfigs();
                                angular.forEach(result.data.data.issueRelationVos, function (issueRelationVo){
                                    issueRelationVo.relationIssueTypeName = $scope.vm.relationIssueTypes[issueRelationVo.relationIssueType].name;
                                    $scope.vm.form.issues.push(issueRelationVo.issueRelation);
                                });

                                $scope.vm.viewer.issueRelationVos = result.data.data.issueRelationVos;
                            }
                        }
                        else {
                            SweetAlert.swal($filter("translate")("issue.errorIssueDetails"), result.data.message.message, "error"); // 이슈 상세 정보 조회 오류
                        }
                    });
                }

                //  이슈 이미지 미리 보기 만들기
                function makePreviewImages(attachedFileVos) {
                    //  미리보기 이미지 초기화
                    $scope.vm.images = [];

                    angular.forEach(attachedFileVos, function (attachedFileVo, $index) {
                        if (attachedFileVo.contentType.indexOf("image") !== -1) {
                            $scope.vm.images.push({
                                id : $index,
                                title : attachedFileVo.name,
                                alt : attachedFileVo.name,
                                thumbUrl : attachedFileVo.path.replace(/\\/gi, "/"),
                                url  : attachedFileVo.path.replace(/\\/gi, "/")
                            });
                        }
                    });
                }

                //  이슈 유형에 연결된 사용자 정의 필드 정보를 입력 폼에서 사용할 수 있게 가공한다.
                function setFormByIssueTypeCustomFields(issueTypeCustomFields) {
                    $scope.vm.viewer.issueCustomFields = [];

                    angular.forEach(issueTypeCustomFields, function (issueTypeCustomField) {
                        switch (issueTypeCustomField.customFieldVo.customFieldType) {
                            case "INPUT" :
                            case "SINGLE_SELECT" :
                                issueTypeCustomField.useValues = "";
                                break;

                            case "MULTI_SELECT" :
                                issueTypeCustomField.useValues = [];
                                break;
                        }

                        $scope.vm.viewer.issueCustomFields.push(issueTypeCustomField);
                    });
                }

                //  이슈에서 사용자가 선택한 사용자 정의 필드 값을 입력 폼에 셋팅한다.
                function setUseValueByIssueTypeCustomFields(issueCustomFieldValues) {
                    angular.forEach(issueCustomFieldValues, function (issueCustomFieldValue) {
                        for (var count in $scope.vm.viewer.issueCustomFields) {
                            var issueCustomField = $scope.vm.viewer.issueCustomFields[count];

                            if (issueCustomField.customFieldVo.id === issueCustomFieldValue.customFieldVo.id) {
                                //  멀티셀렉트 일때
                                if (angular.isArray(issueCustomField.useValues)) {
                                    issueCustomField.useValues.push({
                                        value : issueCustomFieldValue.useValue
                                    });
                                }
                                else {
                                    issueCustomField.useValues = issueCustomFieldValue.useValue;
                                }

                                break;
                            }
                        }
                    });
                }

                function updateActiveHistory() {
                    $scope.vm.activeTab = 'ALL';
                    $scope.fn.makeActiveHistory();
                }

                //  활동 이력 만들기
                function makeActiveHistory() {
                    $scope.vm.viewer.activeHistory = $scope.vm.viewer.issueCommentVos.concat($scope.vm.viewer.issueHistoryVos);
                    $scope.vm.viewer.activeHistory.sort(function (a, b) {
                        return a.registerDate > b.registerDate ? -1 : a.registerDate < b.registerDate ? 1 : 0;
                    });
                }

                //  댓글 등록하기
                function addComment() {
                    var content = {
                        issueId : $scope.vm.viewer.id,
                        description : $rootScope.preventXss($scope.vm.viewer.comment)
                    };

                    IssueComment.add($resourceProvider.getContent(
                        content,
                        $resourceProvider.getPageContent(0, 0))).then(function (result) {

                        if (result.data.message.status === "success") {
                            $scope.vm.viewer.comment = "";
                            $scope.fn.getCommentList();
                        }
                        else {
                            SweetAlert.error($filter("translate")("issue.failedToRegisterComments"), result.data.message.message); // 댓글 등록 실패
                        }
                    });
                }

                //  댓글 삭제
                function removeComment(comment) {
                    //  삭제 알림
                    SweetAlert.swal({
                            title : $filter("translate")("issue.deleteComments"), // "댓글 삭제"
                            text : $filter("translate")("issue.wantToDeleteTheSelectedComments"), // "선택한 댓글을 삭제하겠습니까? 삭제된 댓글은 복구할 수 없습니다."
                            type : "warning",
                            showCancelButton : true,
                            confirmButtonColor : "#DD6B55",
                            confirmButtonText : $filter("translate")("common.delete"), // "삭제"
                            cancelButtonText : $filter("translate")("common.cancel"), // "취소"
                            closeOnConfirm : false,
                            closeOnCancel : true
                        },
                        function (isConfirm) {
                            SweetAlert.close();

                            if (isConfirm) {
                                $rootScope.spinner = true;

                                IssueComment.remove($resourceProvider.getContent(
                                    {removeIds : [comment.id]},
                                    $resourceProvider.getPageContent(0, 0))).then(function (result) {

                                    if (result.data.message.status === "success") {
                                        $timeout(function () {
                                            SweetAlert.success($filter("translate")("common.deleteSucceeded"), result.data.message.message); // 삭제 성공
                                        }, 100);

                                        $scope.fn.getCommentList();
                                    }
                                    else {
                                        $timeout(function () {
                                            SweetAlert.error($filter("translate")("issue.failedToDeleteComments"), result.data.message.message); // "댓글 삭제 실패"
                                        }, 100);
                                    }

                                    $rootScope.spinner = false;
                                });
                            }
                        });
                }

                //  댓글 목록 가져오기
                function getCommentList() {
                    IssueComment.find($resourceProvider.getContent(
                        {issueId : $scope.vm.viewer.id},
                        $resourceProvider.getPageContent(0, 0))).then(function (result) {

                        if (result.data.message.status === "success") {
                            $scope.vm.viewer.issueCommentVos = result.data.data;
                        }
                        else {
                            SweetAlert.swal({
                                title : $filter("translate")("issue.failedToGetCommentListData"), // "댓글 목록 데이터 가져오기 실패"
                                text : result.message.message,
                                type : "error"
                            });
                        }
                    });
                }

                //  첨부 파일 목록
                function getAttachedFiles() {
                    var content = {
                        issueId : $scope.vm.viewer.id
                    };

                    AttachedFile.find($resourceProvider.getContent(
                        content,
                        $resourceProvider.getPageContent(0, 0))).then(function (result) {

                        if (result.data.message.status === "success") {
                            $scope.vm.viewer.attachedFileVos = result.data.data;
                        }
                        else {
                            SweetAlert.error($filter("translate")("issue.failedToAttachmentList"), result.message.message); // "첨부 파일 목록 조회 실패"
                        }
                    });
                }

                //  특정 사용자에게 이슈를 메일로 발송
                function sendMail(issueId, projectId) {
                    $uibModal.open({
                        templateUrl : 'views/issue/issueSendMail.html',
                        size : "md",
                        controller : 'issueSendMailController',
                        backdrop : 'static',
                        resolve : {
                            parameter : function () {
                                return {
                                    issueId : issueId,
                                    projectId : projectId
                                };
                            }
                        }
                    });
                }

                //  변경 정보를 확인한다.
                function versionView(issueId) {
                    $uibModal.open({
                        templateUrl : 'views/issue/issueVersionView.html',
                        size : "lg",
                        controller : 'issueVersionViewController',
                        backdrop : 'static',
                        resolve : {
                            parameter : function () {
                                return {
                                    issueId : issueId
                                };
                            }
                        }
                    });
                }

                //  예약 정보를 확인 및 변경 한다.
                function reservation(issueId) {
                    $uibModal.open({
                        templateUrl : 'views/issue/issueReservation.html',
                        size : "sm",
                        controller : 'issueReservationController',
                        backdrop : 'static',
                        resolve : {
                            parameter : function () {
                                return {
                                    issueId : issueId
                                };
                            }
                        }
                    });
                }

            }
        ]);
    }
);