'use strict';

define(['app',
        'angular'
    ],
    function (app, angular) {

        app.controller('commonController', ['$scope', '$rootScope', '$log', 'Auth', '$state', 'User', '$resourceProvider', '$uibModal', 'SweetAlert', 'Workspace', '$translate', '$q',
            '$interval', 'IssueSearch', '$filter', 'Notice', 'Project', 'IssueType',
            function ($scope, $rootScope, $log, Auth, $state, User, $resourceProvider, $uibModal, SweetAlert, Workspace, $translate, $q, $interval, IssueSearch, $filter, Notice, Project, IssueType) {

                $scope.fn = {
                    logout: logout,    //  로그아웃
                    startWebSock: startWebSock,    //  웹 소켓 시작
                    changeLastWorkspace: changeLastWorkspace,  //  마지막 접근 업무 공간
                    changeLastProject: changeLastProject, // 프로젝트 변경
                    invite: invite,    //  사용자 초대하기
                    findAllWorkproject: findAllWorkproject,  //  사용자가 참여하는 프로젝트 목록 가져오기
                    addIssue: addIssue, //  이슈 만들기 팝업 표시
                    makeIssueSearch: makeIssueSearch,  //  이슈 번호를 저장한 후 이슈 목록으로 이동한다.
                    disconnectSocket: disconnectSocket,    //  웹 소켓 연결 해제
                    sendMessage: sendMessage,
                    moveMenu : moveMenu,
                    findIssueList : findIssueList,   // 사이드바 이슈 목록 가져오기
                    changeIssueListMenu : changeIssueListMenu,
                    setLastIssueType : setLastIssueType
                };

                $scope.vm = {
                    workProject : -1,
                    message: "",
                    workProjectId : -1
                };



                //  시스템에서 특정 이슈로 바로 이동할 수 있도록 해준다.
                $scope.$on("makeIssueSearch", function (event, args) {
                    //  이슈 번호를 저장한 후 이슈 목록으로 이동한다.
                    $scope.fn.makeIssueSearch(args.projectKey, args.issueNumber);
                });

                // 이슈 유형 변경시
                $scope.$on("modifyIssueType", function (event, args) {
                    findIssueList($rootScope.workProject != null ? $rootScope.workProject.id : null);
                });

                //  프로젝트 목록 화면 새로 고침시
                $scope.$on("getProjectList", function () {
                    findAllWorkproject();
                });

                $scope.$on("changedLastProject", function () {
                    if ($rootScope.workProject != null) {
                        $scope.fn.findIssueList($rootScope.workProject.id);
                    }
                });

                function setLastIssueType() {
                    if (User != null) {
                        User.updateLastIssueType($resourceProvider.getContent(
                            {lastIssueTypeId: $rootScope.getCurrentIssueTypeId()},
                            $resourceProvider.getPageContent(0, 0))).then(function (result) {

                            if (result.data.message.status === "success") {

                            }
                        });
                    }
                }

                function changeIssueListMenu(issueTypeId) {
                    $rootScope.issueTypeMenu = null;
                    for (var issueType of $rootScope.workIssueTypes) {
                        if (issueType.id === issueTypeId) {
                            $rootScope.issueTypeMenu = issueType;
                            break;
                        }
                    }

                    // sidebar 클릭시 프로젝트 아이디 설정
                    $rootScope.changeLastProject($rootScope.issueTypeMenu.projectVo.id, false, false);

                    if ($rootScope.issueTypeMenu != null) {
                        moveMenu("issues.list");
                    }

                    $rootScope.$broadcast("changeIssueListMenu", $rootScope.issueTypeMenu);

                    if ($rootScope.user.lastIssueTypeId !== issueTypeId) {
                        $scope.fn.setLastIssueType(issueTypeId);
                    }

                }

                function moveMenu(stateName) {
                    if ($state.current.name == stateName) {
                        $state.reload();
                    } else {
                        $state.go(stateName);
                    }
                }

                //  메세지 발송
                function sendMessage() {
                    var content = {
                        description : $scope.vm.message,
                        userIds : [1]
                    };

                    Notice.send($resourceProvider.getContent(content,
                        $resourceProvider.getPageContent(0, 0))).then(function (result) {
                    });
                }

                //  이슈 번호를 저장한 후 이슈 목록으로 이동한다.
                function makeIssueSearch(projectKey, issueNumber) {
                    var combinationIssueNumber = projectKey;
                    if (issueNumber != undefined) {
                        combinationIssueNumber += "-" + issueNumber;
                    }

                    var content = {
                        conditions: JSON.stringify({
                            search: {
                                combinationIssueNumber: combinationIssueNumber
                            }
                        })
                    };

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

                        if (result.data.message.status === "success") {
                            moveMenu("issues.list");
                        } else {
                            SweetAlert.error($filter("translate")("issue.failedToSaveFieldConditions"), result.data.message.message); // "검색 필드 조건 저장 실패"
                        }
                    });
                }


                //  이슈 만들기 팝업 표시
                function addIssue() {
                    $uibModal.open({
                        templateUrl: 'views/issue/issueAdd.html',
                        size: "lg",
                        controller: 'issueAddController',
                        backdrop: 'static'
                    });
                }

                //  참여하는 프로젝트 목록 가져오기
                function findAllWorkproject() {
                    var deferred = $q.defer();

                    var defaultName = $filter("translate")("common.totalProject");
                    var defaultProject = {id:-1, name: defaultName, customName:"[ "+ defaultName + " ]" };

                    $rootScope.projects = [];
                    $rootScope.projects.push(defaultProject);
                    $rootScope.workProject = defaultProject;

                    Project.findListWork($resourceProvider.getContent({},
                        $resourceProvider.getPageContent(0, 1000))).then(function (result) {
                        if (result.data.message.status === "success") {
                            var projects = result.data.data;

                            if (projects != undefined && projects.length > 0) {
                                // 마지막 사용한 프로젝트 조회
                                var datas = [];
                                datas.push(defaultProject);
                                for (var count in projects) {
                                    var project = projects[count];
                                    datas.push(project);
                                    project.depth = 0;
                                    project.customName = project.name;
                                    setChildren(project, datas, project.depth);

                                    if ($rootScope.user.lastProjectId === project.id) {
                                        $rootScope.workProject = project;
                                    }

                                    var id = $rootScope.workProject.id === -1 ? null : $rootScope.workProject.id;
                                    $scope.fn.findIssueList(id);
                                }
                                $rootScope.projects = datas;
                            }

                            if ($rootScope.user.lastProjectId == null) {
                                $rootScope.user.lastProjectId = -1;
                            }
                        }
                        deferred.resolve(result.data.data);
                    });

                    return deferred.promise;
                }

                function setChildren(row, datas, depth) {
                    depth++;
                    var childProjects = row.childProjects;
                    if (childProjects != undefined && childProjects.length > 0) {
                        for (var child of childProjects) {
                            child.depth = depth;
                            var space = "";
                            for (var i=0;i<depth;i++) {
                                if (i==depth-1) {
                                    space += "┗\u00A0";
                                } else {
                                    space += "\u00A0\u00A0";
                                }
                            }
                            child.customName = space + child.name;
                            datas.push(child);

                            if ($rootScope.user.lastProjectId === child.id) {
                                $rootScope.workProject = child;
                            }

                            setChildren(child, datas, depth);
                        }
                    }
                    return datas;
                }


                //  사용자 초대
                function invite() {
                    $uibModal.open({
                        templateUrl: 'views/userInvite/userInvite.html',
                        size: "md",
                        controller: 'userInviteController',
                        backdrop: 'static'
                    });
                }

                //  현재 프로젝트 변경시

                // 이슈 유형 목록 가져오기
               function findIssueList(projectId) {
                   //  이슈 타입 목록 검색 조건을 만든다.
                   var conditions = {
                       projectId : projectId > -1 ? projectId : null,
                       useProject : true,
                       deep : "01" //  이슈 유형에 연결된 워크플로우 정보를 찾는다.
                   }
                   IssueType.find($resourceProvider.getContent(conditions,
                       $resourceProvider.getPageContent(0, 100))).then(function (result) {

                       if (result.data.message.status === "success") {
                           $rootScope.workIssueTypes = result.data.data;

                           if ($rootScope.workIssueTypes != null && $rootScope.workIssueTypes.length > 0) {
                               $rootScope.workIssueTypes.forEach(function (issueType) {
                               });
                           } else {
                               $state.go('dashboards.dashboard');
                           }
                       }
                       else {
                           SweetAlert.error($filter("translate")("managementType.failedToIssueTypeList"), result.data.message.message); // "이슈 유형 목록 조회 실패"
                       }
                   });
               }



                // 프로젝트 변경
                function changeLastProject(projectId) {
                   $rootScope.changeLastProject(projectId);


                }

                //  업무 공간 변경
                function changeLastWorkspace(workspaceId) {
                    User.updateLastWorkspace($resourceProvider.getContent(
                        {lastWorkspaceId: workspaceId},
                        $resourceProvider.getPageContent(0, 0))).then(function (result) {

                        if (result.data.message.status === "success") {
                            $rootScope.user = result.data.data;
                            $rootScope.setCurrentIssueTypeId()
                            $state.go($state.current, {}, {reload: true});

                            if ($state.current.name === "dashboards.dashboard") {
                                $state.go($state.current, {}, {reload: true});
                            } else {
                                $state.go("dashboards.dashboard");
                            }
                        }
                    });
                }

                //  로그아웃
                function logout() {
                    // edit by zenith at 20200801
                    // before set socket connection call disconnection, fire error so catch
                    try {
                        //  웹 소켓 연결 해제
                        $scope.fn.disconnectSocket();
                    } catch(e) {
                        $log.debug("Error disconnectSocket  : ", e);
                    }
                    Auth.logout();
                    $state.go('login');
                }

                //  최초 실행 - 사용자 세션 조회시, 10초마다 확인하여 끊겨있으면 다시 연결 시도
                function startWebSock() {
                    $rootScope.webSocket.socket = new SockJS("/owl-socket");
                    $rootScope.webSocket.client = Stomp.over($rootScope.webSocket.socket); //Stomp client 구성


                    $rootScope.webSocket.client.connect('', '', function (frame) {
                        //  사용자 목록
                        $rootScope.webSocket.client.subscribe('/session/user-list', function (userList) {
                            $rootScope.users = JSON.parse(userList.body);

                            if ($scope.$root.$$phase !== '$apply' && $scope.$root.$$phase !== '$digest') {
                                $scope.$apply();
                            }

                            if ($rootScope.isDefined($rootScope.webSocket.client)) {
                                $rootScope.webSocket.client.send('/app/session/alive', {}, '');
                            }

                            $log.debug("소켓 연결 사용자 정보 : ", $rootScope.users);
                        });

                        // 사용자에게 메세지 보내기
                        $rootScope.webSocket.client.subscribe('/user/notification/message', function (notification) {
                            SweetAlert.warning("메세지 전달", notification.body);
                        });

                        // 업무 공간 사용자 초과 알림
                        $rootScope.webSocket.client.subscribe('/user/notification/workspace-max-user-excess', function (notification) {
                            var body = JSON.parse(notification.body);
                            SweetAlert.warning($filter("translate")("common.exceedsMaximumUsersWorkspace"), body.message); // "업무 공간 최대 사용자 초과"
                        });

                        //  참여 업무 공간 삭제 알림 - 해당 업무 공간를 보고 있을 때
                        $rootScope.webSocket.client.subscribe('/user/notification/workspace-remove', function (notification) {
                            var body = JSON.parse(notification.body);
                            SweetAlert.warning($filter("translate")("common.deleteParticipatingWorkspaceReminder"), body.message); // "참여 업무 공간 삭제 알림"

                            $scope.fn.findAllWorkspace().then(function () {
                                //  로그인한 사용자 정보를 초기화해서 변경된 업무 공간 정보로 대시보드 재조회
                                User.updateUserSession({}).then(function (result) {
                                    if (result.data.message.status === "success") {
                                        $rootScope.user = result.data.data;  //  전역으로 사용하는 로그인 사용자 정보.
                                    } else {
                                        SweetAlert.error($filter("translate")("common.failedToUpdateParticipatingSessions"), body.message); // "참여 세션 업데이트 실패"
                                    }

                                    //  업무 공간 초기화하여 서버에서 다시 목록 가져오게 하기
                                    if ($state.current.name === "dashboards.dashboard") {
                                        $state.go($state.current, {}, {reload: true});
                                    } else {
                                        $state.go("dashboards.dashboard");
                                    }
                                });
                            });
                        });

                        //  참여 업무 공간 비활성화 알림 - 해당 업무 공간를 보고 있을 때
                        $rootScope.webSocket.client.subscribe('/user/notification/workspace-disabled', function (notification) {
                            // edit by zenith at 20200801
                            // direct oug out cause stand alone have just one workspace
                            SweetAlert.warning($filter("translate")("common.disableParticipationWorkspace"), $filter("translate")("common.disableParticipationWorkspaceMessage"));
                            $rootScope.$broadcast("logout");

                            /*var body = JSON.parse(notification.body);
                            SweetAlert.warning($filter("translate")("common.disableParticipationWorkspace"), body.message); // "참여 업무 공간 비활성화 알림"

                            $scope.fn.findAllWorkspace().then(function () {
                                //  로그인한 사용자 정보를 초기화해서 변경된 업무 공간 정보로 대시보드 재조회
                                User.updateUserSession({}).then(function (result) {
                                    if (result.data.message.status == "success") {
                                        $rootScope.user = result.data.data;  //  전역으로 사용하는 로그인 사용자 정보.
                                    }
                                    else {
                                        SweetAlert.error($filter("translate")("common.failedToUpdateParticipatingSessions"), body.message); // "참여 세션 업데이트 실패"
                                    }

                                    //  업무 공간 초기화하여 서버에서 다시 목록 가져오게 하기
                                    if ($state.current.name == "dashboards.dashboard") {
                                        $state.go($state.current, {}, {reload : true});
                                    }
                                    else {
                                        $state.go("dashboards.dashboard");
                                    }
                                });
                            });*/
                        });

                        //  참여 업무 공간 제외/추가 될때 업무 공간 업데이트
                        $rootScope.webSocket.client.subscribe('/user/notification/workspace-update', function () {
                            $scope.fn.findAllWorkspace();
                        });

                        //  시스템 알림 오류 - ModelAndView 에서 Exception 발생시 페이지 이동이 일어나는 현상을 수정
                        $rootScope.webSocket.client.subscribe('/user/notification/system-alert', function (notification) {
                            var body = JSON.parse(notification.body);
                            SweetAlert.warning($filter("translate")("common.alertsAboutSystem"), body.message); // "시스템 알림 정보"
                        });

                        //  참여 업무 공간 제외/추가 될때 업무 공간 업데이트
                        $rootScope.webSocket.client.subscribe('/user/notification/file-upload-process', function (notification) {
                            var body = JSON.parse(notification.body);

                            $rootScope.$broadcast("displayFileUpload", body);
                        });

                        //  참여 프로젝트 목록 업데이트
                        $rootScope.$broadcast("refreshWorkproject");
                    });
                }

                //  웹 소켓 연결 해제
                function disconnectSocket() {
                    if ($rootScope.webSocket.client != null) {
                        $rootScope.webSocket.client.disconnect(function () {
                            $log.debug("소켓 종료");
                        });
                    }
                }


                //  웹 소켓 시작
                $scope.$on("startSocket", function () {
                    $log.debug("소켓 시작");
                    //  웹 소켓 연결
                    $scope.fn.startWebSock();
                });

                //  로그아웃
                $scope.$on("logout", function () {
                    $scope.fn.logout();
                });

                //  업무 공간 목록 새로고침
                $scope.$on("refreshWorkspace", function () {
                    $scope.fn.findAllWorkspace();
                });

                //  업무 프로젝트 목록 새로고침
                $scope.$on("refreshWorkproject", function () {
                    $scope.fn.findAllWorkproject();
                });


                //  10초마다 웹 소켓 연결을 확인하는 폴링 이벤트
                $interval(function () {
                    //$log.debug("10초마다 소켓 연결을 확인합니다.");
                    //  로그인한 사용자 정보가 있을 경우
                    if (angular.isDefined($rootScope.user)) {
                        if ($rootScope.user.id != null) {
                            //  만약 웹소켓이 연결되어 있지 않으면 재연결 시도
                            if ($rootScope.webSocket.client == null || !$rootScope.webSocket.client.connected) {
                                $log.debug("소켓 연결이 끊겨 있어 소켓을 연결합니다.");
                                $rootScope.$broadcast("startSocket");
                            }
                        }
                    }
                }, 10000);
            }
        ]);
    }
);