define([
    'require'
    , 'jquery'
    , 'nbextensions/visualpython/src/common/constant'
    , 'nbextensions/visualpython/src/common/StringBuilder'
    , 'nbextensions/visualpython/src/common/vpCommon'
    , 'nbextensions/visualpython/src/common/vpMakeDom'
    , 'nbextensions/visualpython/src/common/kernelApi'
], function(requirejs, $, vpConst, sb, vpCommon, vpMakeDom, kernelApi) {
    
    const { renderSpan, renderLi } = vpMakeDom;


    // Temporary constant data
    const NAVIGATION_DIRECTION_TYPE = {
        TOP: 0,
        TO: 1,
        PREV: 2,
        INIT: 3
    }

    /**
     * @class FileNavigation
     * @param {string} type
     * @param {object} state
     * @constructor
     */
    var FileNavigation = function(type, state) {
        this.uuid = vpCommon.getUUID();
        this.type = type;
        // state types
        this.state = {
            direction: '',
            fileType: '',
            filePath: '',
            fileName: '',
            extensions: [],
            showAll: false
        };
        this.state = { ...this.state, ...state };
        this.pathStack = [];

        this.searcher = new FileSearcher(this);
        this.searcher.getNowDirectory();

        // set extension using given file type
        this.setFileState(type);
    }

    /**
     * File Types
     */
    FileNavigation.FILE_TYPE = {
        SAVE_VP_NOTE: 'save_vp_note',
        OPEN_VP_NOTE: 'open_vp_note',
        SAVE_FILE: 'save_file',
        OPEN_FILE: 'open_file',
        SAVE_IMG_FILE: 'save_img_file',
        OPEN_IMG_FILE: 'open_img_file'
    }

    FileNavigation.FILE_TYPE_DISTRIBUTE = { 
        SAVE: [
            FileNavigation.FILE_TYPE.SAVE_VP_NOTE,
            FileNavigation.FILE_TYPE.SAVE_FILE,
            FileNavigation.FILE_TYPE.SAVE_IMG_FILE
        ],
        OPEN: [
            FileNavigation.FILE_TYPE.OPEN_VP_NOTE,
            FileNavigation.FILE_TYPE.OPEN_FILE,
            FileNavigation.FILE_TYPE.OPEN_IMG_FILE
        ]
    }

    FileNavigation.prototype.wrapSelector = function(selector) {
        return vpCommon.formatString('.{0} {1}', this.uuid, selector);
    }

    /**
     * 
     * @param {Array} arr fileExtensions list 
     */
    FileNavigation.prototype.setExtensions = function(arr) {
        this.state.extensions = arr;
    }

    FileNavigation.prototype.setFileState = function(type) {
        switch (type) {
            case FileNavigation.FILE_TYPE.SAVE_VP_NOTE:
            case FileNavigation.FILE_TYPE.OPEN_VP_NOTE:
                this.state.extensions = ['vp', 'txt'];
                break;
            case FileNavigation.FILE_TYPE.SAVE_IMG_FILE:
            case FileNavigation.FILE_TYPE.OPEN_IMG_FILE:
                this.state.extensions = ['png', 'jpg', 'jpeg', 'gif'];
                break;
            case FileNavigation.FILE_TYPE.SAVE_FILE:
            case FileNavigation.FILE_TYPE.OPEN_FILE:
                break;
        }
    }

    FileNavigation.prototype.pushPath = function(path) {
        this.state.pathStack.push(path);
        return true;
    }

    FileNavigation.prototype.popPath = function() {
        if (this.state.pathStack.length <= 0) {
            return undefined;
        }
        return this.state.pathStack.pop();
    }

    FileNavigation.prototype.init = async function() {
        var that = this;

        var loadURLstyle = Jupyter.notebook.base_url + vpConst.BASE_PATH + vpConst.STYLE_PATH;
        var loadURLhtml = Jupyter.notebook.base_url + vpConst.BASE_PATH + vpConst.SOURCE_PATH + "component/fileNavigation/index.html";
        
        vpCommon.loadCss( loadURLstyle + "component/fileNavigation.css");

        await $(`<div id="vp_fileNavigation" class="${this.uuid}"></div>`).load(loadURLhtml, () => {  
            that.state.direction = NAVIGATION_DIRECTION_TYPE.INIT;
            var dirObj = {
                direction: that.state.direction,
                destDir: '.',
                useFunction: false
            }         
            that.renderThis(dirObj);
            that.bindEvent();

            that.open();
        }).appendTo("#site");
    }

    FileNavigation.prototype.open = function() {
        this.init();
        
        $('#vp_fileNavigation.' + this.uuid).show();
    }

    FileNavigation.prototype.close = function() {
        $('#vp_fileNavigation.' + this.uuid).remove();
        
        // 파일 네비게이션에서 생성된 script 파일 삭제
        vpCommon.removeHeadScript('fileNavigation');
    }

    FileNavigation.prototype.filterFileInfoArr = function(fileInfoArr) {
        var allowExtensionList = this.state.extensions;
        var filtered_varList = fileInfoArr.filter((data, index) => {
            if (index == 0) {
                return true;
            }

            if (data.type && data.type == 'dir') {
                // true if it is directory(folder)
                return true;
            } else {
                if (data.name) {
                    var extension = data.name.substring(data.name.lastIndexOf('.') + 1);
                    if (allowExtensionList.includes(extension)) {
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            }
        });

        // FIXME: 쓸 이유 없으면 삭제
        if (FileNavigation.FILE_TYPE_DISTRIBUTE.SAVE.includes(this.state.fileType)) {
            // save

        } else {
            // open

        }
        return filtered_varList;
    }

    FileNavigation.prototype.renderThis = function(dirObj) {
        var that = this;
        this.searcher.executeCurrentPath(dirObj, function(resultInfoArr) {
            console.log('resultInfoArr:', resultInfoArr);
            
            // get current dir
            var currentDirStr = resultInfoArr[0].current.split('//').join('/');
            that.state.currentDir = currentDirStr;

            var splitedDirStrArr = currentDirStr.split('/');
            var rootFolderName = splitedDirStrArr[splitedDirStrArr.length - 1];
    
            var firstIndex = currentDirStr.indexOf(that.searcher.state.notebookDir);

            var currentRelativePathStr = '';
            if ( firstIndex === -1 ) {
                currentRelativePathStr = currentDirStr.substring(that.searcher.state.notebookDir.length + 1, currentDirStr.length);
            } else {
                currentRelativePathStr = currentDirStr.substring(firstIndex, currentDirStr.length); 
            }

            // filter by fileType
            var filtered_varList = that.filterFileInfoArr(resultInfoArr);

            that.renderCurrentDirPathInfo(filtered_varList);
            that.renderNowLocation(currentDirStr, currentRelativePathStr);

        });
    }

    FileNavigation.prototype.renderNowLocation = function(currentDirStr, currentRelativePathStr) {
        // TODO: render Now location
    }

    /** */
    FileNavigation.prototype.renderCurrentDirPathInfo = function(dirInfoArr) {
     
        $('.fileNavigationPage-body').empty();
        var currentDirRootDom = $('.fileNavigationPage-body');
        var { folderArr, fileArr } = this.makeFolderOrFileDomArr(dirInfoArr);
        var fileNavigationPageUl = $(`<ul class='fileNavigationPage-ul'>
                                      </ul>`);
  
        folderArr.forEach(dom => {
            fileNavigationPageUl.append(dom);
        });
        fileArr.forEach(dom => {
            fileNavigationPageUl.append(dom);
        });
        currentDirRootDom.append(fileNavigationPageUl);
    }

    /** <div/> 태그 형식의 폴더 디렉토리를 만드는 함수 
     * @param {JSON} node
    */
     FileNavigation.prototype.makeFolderDom = function(node) {
        var that = this;

        var folderName = node.name;
        var folderPath = node.path;

        var directoryLi = renderLi({class: 'fileNavigationPage-li'});
        var directorySpan = renderSpan({class:'fileNavigationPage-column'});
        var directoryI = $(`<i class="fileNavigationPage-dir-text 
                                        item_icon 
                                        folder_icon 
                                        icon-fixed-width">
                                ${folderName}
                            </i>`);
        $(directoryI).click(function() {
            var dirObj = {
                direction: NAVIGATION_DIRECTION_TYPE.TO,
                destDir: folderPath
            }

            // initialize sidebar-menu selection
            $('.fnp-sidebar-menu').removeClass('selected');

            that.renderThis(dirObj);
        });

        $(directoryLi).append($(directorySpan).append(directoryI));
        return directoryLi;
    }

    FileNavigation.prototype.renderSaveFileBox = function() {
        
    }

    /**  <div/> 태그 형식의 파일 디렉토리를 만드는 함수
     * @param {JSON} node 
     */
     FileNavigation.prototype.makeFileDom = function(node) {
        var that = this;
        var navigationState = this.state;
        var fileName = node.name;

        var directoryLi = renderLi({class: 'fileNavigationPage-li'});
        var directoryI = $(`<i class="fileNavigationPage-dir-text 
                                        item_icon 
                                        file_icon 
                                        icon-fixed-width">
                                ${fileName}
                            </i>`);
        directoryI.click(function() {
            var dirPath = that.makeNewCurrRelativePath();
            var extension = fileName.substring(fileName.lastIndexOf('.') + 1);
            var allowExtensionList = navigationState.extensions;
            // if it is not allowed extension
            if (!allowExtensionList.includes(extension)) {
                vpCommon.renderAlertModal('Not supported file type');
                return;
            }
            that.handleSelectFile(dirPath, fileName);
        });

        directoryLi.append(directoryI);
        return directoryLi;
    }

    
    FileNavigation.prototype.makeFolderOrFileDomArr = function(dirInfoArr) {
        var that = this;

        var folderArr = [];
        var fileArr = [];

        var nodeInfo = { name:'', 
                         type:'' };
        // 디렉토리 정보가 담긴 자바스크립트 배열 dirInfoArr을 index 1부터 1씩 늘려가면서
        // 폴더인지 파일인지 확인후 html 태그를 만든다. 
        // index 0의 데이터는 현재 디렉토리가 담긴 별도의 특수 데이터라 건너 뛴다.
        var index = 1;
        while(index < dirInfoArr.length) {
            nodeInfo = dirInfoArr[index];
            var tempDom = null;
            // 디렉토리 정보가 폴더 일 경우
            if (nodeInfo.type === 'dir') {
                tempDom = that.makeFolderDom(nodeInfo);
                folderArr.push(tempDom);
            } else {
            // 디렉토리 정보가 파일 일 경우
                tempDom = that.makeFileDom(nodeInfo);
                fileArr.push(tempDom);
            }

            index++;
        }

        return {
            folderArr, fileArr
        }
    }

    FileNavigation.prototype.makeNewCurrRelativePath = function() {
        var searchState = this.searcher.state;
        var dirPath = searchState.relativeDir;
        /** 
         *  만약 현재 전체 path가 C:/Users/L.E.E/Desktop/Bit Python이라면,
         *  baseFolder 변수에 Bit Python가 저장됨
         *  즉 파일 네비게이션을 연 시점의 폴더가 baseFolder 
         */
        var baseFolder = searchState.baseFolder;
        /** 
         *  만약 현재 전체 path가 C:/Users/L.E.E/Desktop/Bit Python이라면,
         *  Jupyter.notebook.notebook_path 는 'Desktop/Bit Python/Untitled4.ipynb' 
         *  noteBookFolder 변수에 Desktop가 저장됨
         *  즉 Jupyter.notebook.notebook_path의 폴더가 noteBookFolder
         */
        var noteBookFolder = searchState.notebookFolder;


        /** 파일 네비게이션을 실행한 baseFolder 이름이 현재 상대 경로에 있을때 */
        if (dirPath.indexOf(baseFolder) !== -1) {
            var baseFolderIndex = dirPath.indexOf(baseFolder);
            dirPath = dirPath.substring(baseFolderIndex,dirPath.length);
            dirPath = dirPath.replace(baseFolder, '');
        }
        
        /** 만약 baseFolder 이름과 noteBookFolder 이름이 동일하면 
         *  dirPath 안에 존재하는 noteBookFolder이름을  replace 하지 않음
         * */
        if (baseFolder !== noteBookFolder) {
            dirPath = dirPath.replace(noteBookFolder, '');
        }

        if (dirPath[0] === '/') {
            dirPath = dirPath.substring(1, dirPath.length);
        }
        return dirPath;
    }

    FileNavigation.prototype.bindEvent = function() {
        
    }

    FileNavigation.prototype.handleSelectFile = function(relativeDirPath, filePathStr) {
        var that = this;
        var state = this.searcher.state;

        /** relative path */
        var baseFolder = state.baseFolder;
        var baseDirStr = state.baseDir;
        var noteBookPathStr = state.notebookDir;
        var currentDirStr = state.currentDir;

        var noteBookPathStrLength = noteBookPathStr.length;
        var baseDirStrLength = baseDirStr.length;

        /** upDirectoryCount는 파일 네비게이션을 연 시점의 path 경로 에서 
         *  얼마만큼 상위 path로 올라갔는지 횟수를 count하는 변수 
         */
         var upDirectoryCount = 0;
         var _upDirectoryCount = 0;
 
         var splitedNoteBookPathStrArray = noteBookPathStr.split('/');
         var splitedBaseDirArray = baseDirStr.split('/');
         var splitedCurrentDirArray  = currentDirStr.split('/');
 
         var relativeBaseDirArray = splitedBaseDirArray.slice(splitedNoteBookPathStrArray.length, splitedBaseDirArray.length);
         var relativeCurrentDirArray = splitedCurrentDirArray.slice(splitedNoteBookPathStrArray.length, splitedCurrentDirArray.length);
 
         /** 최초 파일 네비게이션을 연 시점의 path 경로와 Jupyter notebook의 path 경로를 비교하여
          *  최초 파일 네비게이션을 연 시점의 path에서 얼마만큼 상위로 올라가야 Jupyter notebook의 path 경로에 도달할 수 있는지 count
          */
         var _baseDirStrLength = baseDirStrLength;
         while ( noteBookPathStrLength < _baseDirStrLength ) {
             _baseDirStrLength--;
             if ( baseDirStr[_baseDirStrLength] === '/') {
                 upDirectoryCount += 1;
             }
         }
 
         /** Jupyter notebook의 path 경로와 현재 이동한 path 경로를 비교하여
          *  Jupyter notebook의 path 경로에서 얼마만큼 하위로 내려와야 현재 이동한 path 경로에 도달할 수 있는지 count
          */
         relativeCurrentDirArray.forEach((forderName,index) => {
             if ( forderName === relativeBaseDirArray[index] ) {
                 upDirectoryCount -= 1;
             }
         });
        
         /**upDirectoryCount의 숫자 만큼 '../'을 추가
          * upDirectoryCount의 숫자 만큼 다시말하면 '../'가 추가 된 만큼, 현재 path 폴더에서 상위 폴더로 이동했다는 의미.
          */
         _upDirectoryCount = upDirectoryCount;
         var prefixUpDirectory = ``;
         while (_upDirectoryCount-- > 0) {
             prefixUpDirectory += `../`;
         }
 
         var slashstr = `/`;
         if (relativeDirPath === '') {
             slashstr = '';
         }

         /** 최초의 path가 C:/Users/L.E.E/Desktop/Bit Python이라면, baseFolder는 Bit Python
         *  현재 이동한 시점의 path에서 baseFolder인 Bit Python가 존재하지 않을 때
         */
        if (upDirectoryCount > 0 
            && currentDirStr.indexOf(baseFolder) === -1) {
            /** 2020년 12월 21일 single quote 삭제 */
            console.log('path', `${prefixUpDirectory}${relativeDirPath}${slashstr}${filePathStr}`);
            console.log('file', `${filePathStr}`);

            this.resultState.path = `${prefixUpDirectory}${relativeDirPath}${slashstr}${filePathStr}`;
            this.resultState.file = `${filePathStr}`;
        /** 현재 이동한 시점의 path에서 baseFolder인 Bit Python가 존재할 때 */
        } else {
            console.log('path', `./${relativeDirPath}${slashstr}${filePathStr}`);
            console.log('file', `${filePathStr}`);

            this.resultState.path = `./${relativeDirPath}${slashstr}${filePathStr}`;
            this.resultState.file = `${filePathStr}`;
        }

        this.close();
    }

    var FileSearcher = function(navigation) {
        this.navigation = navigation;
        this.state = {
            currentDir: '',

            baseFolder: '',
            baseDir: '',
            relativeDir: '',
            
            notebookFolder: '',
            notebookDir: ''
        }
    }

    FileSearcher.prototype.getNowDirectory = function() {
        var that = this;
        kernelApi.executePython('%pwd', (currentDirStr) => {
            that.state.currentDir = currentDirStr;
            var slicedCurrentDirStr = currentDirStr.slice(1, currentDirStr.length -1);
                slicedCurrentDirStr = slicedCurrentDirStr.replace(/\\/g, `/`);
      
            //** slicedCurrentDirStr = slicedCurrentDirStr.replaceAll("//","/"); 이 기능을 아래 logic으로 대체 */
            var cursor = 0;
            while (slicedCurrentDirStr[cursor] !== undefined ) {
                if(slicedCurrentDirStr[cursor] === "/" && slicedCurrentDirStr[cursor + 1] === "/") {
                    slicedCurrentDirStr = slicedCurrentDirStr.slice(0,cursor) + slicedCurrentDirStr.slice(cursor + 1,slicedCurrentDirStr.length);
                }
                cursor++;
            }
          
            var splitedDirStrArr = slicedCurrentDirStr.split('/');
            /** 만약 현재 전체 path가 C:/Users/L.E.E/Desktop/Bit Python이라면,
             *  BaseFolderStr는  Bit Python
             *  BaseDirStr는  C:/Users/L.E.E/Desktop/Bit Python
             *  RelativePathStr는 Bit Python
             *  RelativePathStr는 파일 네비게이션 이동하면서 계속 달라진다
             */
            var rootFolderName = splitedDirStrArr[splitedDirStrArr.length - 1];
            var notebookPath = Jupyter.notebook.notebook_path;

            that.state.baseFolder = rootFolderName;
            that.state.relativeDir = rootFolderName;
            that.state.baseDir = slicedCurrentDirStr;

            var baseDirStr = slicedCurrentDirStr;

            /** jupyter.notebook.notebook_path 의 값을 토대로
             *  notebookFolder 와 notebookPathStr을 생성
             *  만약 현재 전체 path가 C:/Users/L.E.E/Desktop/Bit Python이라면,
             *  Jupyter.notebook.notebook_path 는 Desktop/Bit Python
             *  notebookFolder는 Desktop
             *  notebookPathStr는 Desktop/Bit Python
             *  사용자가 위로 올라갈 수 있는 최상위 부모 폴더는 L.E.E
             */
            if (notebookPath.indexOf("/") !== -1) {
                var index = 0;
                while ( notebookPath[index] !== "/" ) {
                    if ( notebookPath[index] === undefined ) {
                        break;
                    }
                    index++;
                }
            
                var notebookFolder = notebookPath.substring(0, index);
                var index2 = baseDirStr.indexOf(notebookFolder);
                while (baseDirStr[index2] !== "/") {
                    if ( baseDirStr[index2] === undefined ) {
                        break;
                    }
                    index2++;
                }

                var notebookFullPathStr = baseDirStr.substring(0, index2);
                var index3 = notebookFullPathStr.indexOf(notebookFolder);
                var notebookPathStr = baseDirStr.substring(0, index3 - 1);

                that.state.notebookFolder = notebookFolder;
                that.state.notebookPath = notebookPathStr;
            } else {
                that.state.notebookFolder = rootFolderName;
                that.state.notebookPath = slicedCurrentDirStr;
            }
        })
    }

    FileSearcher.prototype.makeSearchCommand = function(path, useFunction = false) {
        if (path === '') {
            path = '.';
        }
        if (!useFunction) {
            path = "'" + path + "'";
        }
        path = path.replace('\\', '\\\\');
        var sbCode = new sb.StringBuilder();
        sbCode.appendFormat("_vp_print(_vp_search_path({0}))", path);
        return sbCode.toString();
    }

    /**
     * 
     * @param {Object} dirObj {direction, destDir, useFunction} 
     */
    FileSearcher.prototype.executeCurrentPath = function(dirObj, callback) {
        const { destDir, useFunction } = dirObj;
        var currentPathStr = this.makeSearchCommand(destDir, (useFunction? true: false));
        var fileNavigationState = this.navigation.state;
        kernelApi.executePython(currentPathStr, (result) => {
            var varList = JSON.parse(result);

            /** 폴더나 파일 이름에 . 이 들어간 폴더, 파일 제거 */
            var filterd_varList = varList.filter(data => {
                if (data.name && data.name[0] == '.') {
                    return false;
                } else {
                    return true;
                }
            /** 오름차순으로 가져옴 */
            }).sort((a,b) => {
                return a - b;
            });

            callback(filterd_varList);
        })
    }

    return FileNavigation;
});