/* jslint node: true */
'use strict';

//  enigma-bbs
const { MenuModule, MenuFlags } = require('./menu_module');
const stringFormat = require('./string_format.js');
const getSortedAvailableFileAreas =
    require('./file_base_area.js').getSortedAvailableFileAreas;
const getAreaDefaultStorageDirectory =
    require('./file_base_area.js').getAreaDefaultStorageDirectory;
const scanFile = require('./file_base_area.js').scanFile;
const getFileAreaByTag = require('./file_base_area.js').getFileAreaByTag;
const getDescFromFileName = require('./file_base_area.js').getDescFromFileName;
const ansiGoto = require('./ansi_term.js').goto;
const moveFileWithCollisionHandling =
    require('./file_util.js').moveFileWithCollisionHandling;
const pathWithTerminatingSeparator =
    require('./file_util.js').pathWithTerminatingSeparator;
const Log = require('./logger.js').log;
const Errors = require('./enig_error.js').Errors;
const FileEntry = require('./file_entry.js');
const isAnsi = require('./string_util.js').isAnsi;
const Events = require('./events.js');

//  deps
const async = require('async');
const _ = require('lodash');
const temptmp = require('temptmp').createTrackedSession('upload');
const paths = require('path');
const sanatizeFilename = require('sanitize-filename');

exports.moduleInfo = {
    name: 'Upload',
    desc: 'Module for classic file uploads',
    author: 'NuSkooler',
};

const FormIds = {
    options: 0,
    processing: 1,
    fileDetails: 2,
    dupes: 3,
};

const MciViewIds = {
    options: {
        area: 1, //  area selection
        uploadType: 2, //  blind vs specify filename
        fileName: 3, //  for non-blind; not editable for blind
        navMenu: 4, //  next/cancel/etc.
        errMsg: 5, //  errors (e.g. filename cannot be blank)
    },

    processing: {
        calcHashIndicator: 1,
        archiveListIndicator: 2,
        descFileIndicator: 3,
        logStep: 4,
        customRangeStart: 10, //  10+ = customs
    },

    fileDetails: {
        desc: 1, //  defaults to 'desc' (e.g. from FILE_ID.DIZ)
        tags: 2, //  tag(s) for item
        estYear: 3,
        accept: 4, //  accept fields & continue
        customRangeStart: 10, //  10+ = customs
    },

    dupes: {
        dupeList: 1,
    },
};

exports.getModule = class UploadModule extends MenuModule {
    constructor(options) {
        super(options);

        this.setMergedFlag(MenuFlags.NoHistory);

        this.interrupt = MenuModule.InterruptTypes.Never;

        if (_.has(options, 'lastMenuResult.recvFilePaths')) {
            this.recvFilePaths = options.lastMenuResult.recvFilePaths;
        }

        this.availAreas = getSortedAvailableFileAreas(this.client, { writeAcs: true });

        this.menuMethods = {
            optionsNavContinue: (formData, extraArgs, cb) => {
                return this.performUpload(cb);
            },

            fileDetailsContinue: (formData, extraArgs, cb) => {
                //  see displayFileDetailsPageForUploadEntry() for this hackery:
                cb(null);
                return this.fileDetailsCurrentEntrySubmitCallback(null, formData.value); //  move on to the next entry, if any
            },

            //  validation
            validateNonBlindFileName: (fileName, cb) => {
                if (0 === fileName.length) {
                    return cb(new Error('Filename cannot be empty'));
                }

                fileName = sanatizeFilename(fileName); //  remove unsafe chars, path info, etc.
                if (0 === fileName.length) {
                    //  sanatize nuked everything?
                    return cb(new Error('Invalid filename'));
                }

                //  At least SEXYZ doesn't like non-blind names that start with a number - it becomes confused ;-(
                if (/^[0-9].*$/.test(fileName)) {
                    return cb(new Error('Invalid filename'));
                }

                return cb(null);
            },
            viewValidationListener: (err, cb) => {
                const errView = this.viewControllers.options.getView(
                    MciViewIds.options.errMsg
                );
                if (errView) {
                    if (err) {
                        errView.setText(err.message);
                    } else {
                        errView.clearText();
                    }
                }

                return cb(null);
            },
        };
    }

    getSaveState() {
        //  if no areas, we're falling back due to lack of access/areas avail to upload to
        if (this.availAreas.length > 0 && this.viewControllers.options) {
            return {
                uploadType: this.uploadType,
                tempRecvDirectory: this.tempRecvDirectory,
                areaInfo:
                    this.availAreas[
                        this.viewControllers.options
                            .getView(MciViewIds.options.area)
                            .getData()
                    ],
            };
        }
    }

    restoreSavedState(savedState) {
        if (savedState.areaInfo) {
            this.uploadType = savedState.uploadType;
            this.areaInfo = savedState.areaInfo;
            this.tempRecvDirectory = savedState.tempRecvDirectory;
        }
    }

    isBlindUpload() {
        return 'blind' === this.uploadType;
    }
    isFileTransferComplete() {
        return !_.isUndefined(this.recvFilePaths);
    }

    initSequence() {
        const self = this;

        if (0 === this.availAreas.length) {
            //
            return this.gotoMenu(
                this.menuConfig.config.noUploadAreasAvailMenu ||
                    'fileBaseNoUploadAreasAvail'
            );
        }

        async.series(
            [
                function before(callback) {
                    return self.beforeArt(callback);
                },
                function display(callback) {
                    if (self.isFileTransferComplete()) {
                        return self.displayProcessingPage(callback);
                    } else {
                        return self.displayOptionsPage(callback);
                    }
                },
            ],
            () => {
                return self.finishedLoading();
            }
        );
    }

    finishedLoading() {
        if (this.isFileTransferComplete()) {
            return this.processUploadedFiles();
        }
    }

    performUpload(cb) {
        temptmp.mkdir({ prefix: 'enigul-' }, (err, tempRecvDirectory) => {
            if (err) {
                return cb(err);
            }

            //  need a terminator for various external protocols
            this.tempRecvDirectory = pathWithTerminatingSeparator(tempRecvDirectory);

            const modOpts = {
                extraArgs: {
                    recvDirectory: this.tempRecvDirectory, //  we'll move files from here to their area container once processed/confirmed
                    direction: 'recv',
                },
            };

            if (!this.isBlindUpload()) {
                //  data has been sanatized at this point
                modOpts.extraArgs.recvFileName = this.viewControllers.options
                    .getView(MciViewIds.options.fileName)
                    .getData();
            }

            //
            //  Move along to protocol selection -> file transfer
            //  Upon completion, we'll re-enter the module with some file paths handed to us
            //
            return this.gotoMenu(
                this.menuConfig.config.fileTransferProtocolSelection ||
                    'fileTransferProtocolSelection',
                modOpts,
                cb
            );
        });
    }

    continueNonBlindUpload(cb) {
        return cb(null);
    }

    updateScanStepInfoViews(stepInfo) {
        //  :TODO: add some blinking (e.g. toggle items) indicators - see OBV.DOC

        const fmtObj = Object.assign({}, stepInfo);
        let stepIndicatorFmt = '';
        let logStepFmt;

        const fmtConfig = this.menuConfig.config;

        const indicatorStates = fmtConfig.indicatorStates || ['|', '/', '-', '\\'];
        const indicatorFinished = fmtConfig.indicatorFinished || '√';

        const indicator = {};
        const self = this;

        function updateIndicator(mci, isFinished) {
            indicator.mci = mci;

            if (isFinished) {
                indicator.text = indicatorFinished;
            } else {
                self.scanStatus.indicatorPos += 1;
                if (self.scanStatus.indicatorPos >= indicatorStates.length) {
                    self.scanStatus.indicatorPos = 0;
                }
                indicator.text = indicatorStates[self.scanStatus.indicatorPos];
            }
        }

        switch (stepInfo.step) {
            case 'start':
                logStepFmt = stepIndicatorFmt =
                    fmtConfig.scanningStartFormat || 'Scanning {fileName}';
                break;

            case 'hash_update':
                stepIndicatorFmt =
                    fmtConfig.calcHashFormat ||
                    'Calculating hash/checksums: {calcHashPercent}%';
                updateIndicator(MciViewIds.processing.calcHashIndicator);
                break;

            case 'hash_finish':
                stepIndicatorFmt =
                    fmtConfig.calcHashCompleteFormat ||
                    'Finished calculating hash/checksums';
                updateIndicator(MciViewIds.processing.calcHashIndicator, true);
                break;

            case 'archive_list_start':
                stepIndicatorFmt =
                    fmtConfig.extractArchiveListFormat || 'Extracting archive list';
                updateIndicator(MciViewIds.processing.archiveListIndicator);
                break;

            case 'archive_list_finish':
                fmtObj.archivedFileCount = stepInfo.archiveEntries.length;
                stepIndicatorFmt =
                    fmtConfig.extractArchiveListFinishFormat ||
                    'Archive list extracted ({archivedFileCount} files)';
                updateIndicator(MciViewIds.processing.archiveListIndicator, true);
                break;

            case 'archive_list_failed':
                stepIndicatorFmt =
                    fmtConfig.extractArchiveListFailedFormat ||
                    'Archive list extraction failed';
                break;

            case 'desc_files_start':
                stepIndicatorFmt =
                    fmtConfig.processingDescFilesFormat || 'Processing description files';
                updateIndicator(MciViewIds.processing.descFileIndicator);
                break;

            case 'desc_files_finish':
                stepIndicatorFmt =
                    fmtConfig.processingDescFilesFinishFormat ||
                    'Finished processing description files';
                updateIndicator(MciViewIds.processing.descFileIndicator, true);
                break;

            case 'finished':
                logStepFmt = stepIndicatorFmt =
                    fmtConfig.scanningStartFormat || 'Finished';
                break;
        }

        fmtObj.stepIndicatorText = stringFormat(stepIndicatorFmt, fmtObj);

        if (this.hasProcessingArt) {
            this.updateCustomViewTextsWithFilter(
                'processing',
                MciViewIds.processing.customRangeStart,
                fmtObj,
                { appendMultiLine: true }
            );

            if (indicator.mci && indicator.text) {
                this.setViewText('processing', indicator.mci, indicator.text);
            }

            if (logStepFmt) {
                this.setViewText(
                    'processing',
                    MciViewIds.processing.logStep,
                    stringFormat(logStepFmt, fmtObj),
                    { appendMultiLine: true }
                );
            }
        } else {
            this.client.term.pipeWrite(fmtObj.stepIndicatorText);
        }
    }

    scanFiles(cb) {
        const self = this;

        const results = {
            newEntries: [],
            dupes: [],
        };

        self.client.log.debug('Scanning upload(s)', { paths: this.recvFilePaths });

        let currentFileNum = 0;

        async.eachSeries(
            this.recvFilePaths,
            (filePath, nextFilePath) => {
                //  :TODO: virus scanning/etc. should occur around here

                currentFileNum += 1;

                self.scanStatus = {
                    indicatorPos: 0,
                };

                const scanOpts = {
                    areaTag: self.areaInfo.areaTag,
                    storageTag: self.areaInfo.storageTags[0],
                    hashTags: self.areaInfo.hashTags,
                };

                function handleScanStep(stepInfo, nextScanStep) {
                    stepInfo.totalFileNum = self.recvFilePaths.length;
                    stepInfo.currentFileNum = currentFileNum;

                    self.updateScanStepInfoViews(stepInfo);
                    return nextScanStep(null);
                }

                self.client.log.debug('Scanning file', { filePath: filePath });

                scanFile(
                    filePath,
                    scanOpts,
                    handleScanStep,
                    (err, fileEntry, dupeEntries) => {
                        if (err) {
                            return nextFilePath(err);
                        }

                        //  new or dupe?
                        if (dupeEntries.length > 0) {
                            //  1:n dupes found
                            self.client.log.debug('Duplicate file(s) found', {
                                dupeEntries: dupeEntries,
                            });

                            results.dupes = results.dupes.concat(dupeEntries);
                        } else {
                            //  new one
                            results.newEntries.push(fileEntry);
                        }

                        return nextFilePath(null);
                    }
                );
            },
            err => {
                return cb(err, results);
            }
        );
    }

    cleanupTempFiles() {
        temptmp.cleanup(paths => {
            Log.debug(
                { paths: paths, sessionId: temptmp.sessionId },
                'Temporary files cleaned up'
            );
        });
    }

    moveAndPersistUploadsToDatabase(newEntries) {
        const areaStorageDir = getAreaDefaultStorageDirectory(this.areaInfo);
        const self = this;

        async.eachSeries(
            newEntries,
            (newEntry, nextEntry) => {
                const src = paths.join(self.tempRecvDirectory, newEntry.fileName);
                const dst = paths.join(areaStorageDir, newEntry.fileName);

                moveFileWithCollisionHandling(src, dst, (err, finalPath) => {
                    if (err) {
                        self.client.log.error('Failed moving physical upload file', {
                            error: err.message,
                            fileName: newEntry.fileName,
                            source: src,
                            dest: dst,
                        });
                        return nextEntry(null); //  still try next file
                    } else if (dst !== finalPath) {
                        //  name changed; adjust before persist
                        newEntry.fileName = paths.basename(finalPath);
                    }

                    self.client.log.debug('Moved upload to area', { path: finalPath });

                    //  persist to DB
                    newEntry.persist(err => {
                        if (err) {
                            self.client.log.error(
                                'Failed persisting upload to database',
                                { path: finalPath, error: err.message }
                            );
                        }

                        return nextEntry(null); //  still try next file
                    });
                });
            },
            () => {
                //
                //  Finally, we can remove any temp files that we may have created
                //
                self.cleanupTempFiles();
            }
        );
    }

    prepDetailsForUpload(scanResults, cb) {
        async.eachSeries(
            scanResults.newEntries,
            (newEntry, nextEntry) => {
                newEntry.meta.upload_by_username = this.client.user.username;
                newEntry.meta.upload_by_user_id = this.client.user.userId;

                this.displayFileDetailsPageForUploadEntry(newEntry, (err, newValues) => {
                    if (err) {
                        return nextEntry(err);
                    }

                    if (!newEntry.descIsAnsi) {
                        newEntry.desc = _.trimEnd(newValues.shortDesc);
                    }

                    if (newValues.estYear.length > 0) {
                        newEntry.meta.est_release_year = newValues.estYear;
                    }

                    if (newValues.tags.length > 0) {
                        newEntry.setHashTags(newValues.tags);
                    }

                    return nextEntry(err);
                });
            },
            err => {
                delete this.fileDetailsCurrentEntrySubmitCallback;
                return cb(err, scanResults);
            }
        );
    }

    displayDupesPage(dupes, cb) {
        //
        //  If we have custom art to show, use it - else just dump basic info.
        //  Pause at the end in either case.
        //
        const self = this;

        async.waterfall(
            [
                function prepArtAndViewController(callback) {
                    self.prepViewControllerWithArt(
                        'dupes',
                        FormIds.dupes,
                        { clearScreen: true, trailingLF: false },
                        err => {
                            if (err) {
                                self.client.term.pipeWrite(
                                    '|00|07Duplicate upload(s) found:\n'
                                );
                                return callback(null, null);
                            }

                            const dupeListView = self.viewControllers.dupes.getView(
                                MciViewIds.dupes.dupeList
                            );
                            return callback(null, dupeListView);
                        }
                    );
                },
                function prepDupeObjects(dupeListView, callback) {
                    //  update dupe objects with additional info that can be used for formatString() and the like
                    async.each(
                        dupes,
                        (dupe, nextDupe) => {
                            FileEntry.loadBasicEntry(dupe.fileId, dupe, err => {
                                if (err) {
                                    return nextDupe(err);
                                }

                                const areaInfo = getFileAreaByTag(dupe.areaTag);
                                if (areaInfo) {
                                    dupe.areaName = areaInfo.name;
                                    dupe.areaDesc = areaInfo.desc;
                                }
                                return nextDupe(null);
                            });
                        },
                        err => {
                            return callback(err, dupeListView);
                        }
                    );
                },
                function populateDupeInfo(dupeListView, callback) {
                    const dupeInfoFormat =
                        self.menuConfig.config.dupeInfoFormat ||
                        '{fileName} @ {areaName}';

                    if (dupeListView) {
                        dupeListView.setItems(
                            dupes.map(dupe => stringFormat(dupeInfoFormat, dupe))
                        );
                        dupeListView.redraw();
                    } else {
                        dupes.forEach(dupe => {
                            self.client.term.pipeWrite(
                                `${stringFormat(dupeInfoFormat, dupe)}\n`
                            );
                        });
                    }

                    return callback(null);
                },
                function pause(callback) {
                    return self.pausePrompt(
                        { row: self.client.term.termHeight },
                        callback
                    );
                },
            ],
            err => {
                return cb(err);
            }
        );
    }

    processUploadedFiles() {
        //
        //  For each file uploaded, we need to process & gather information
        //
        const self = this;

        async.waterfall(
            [
                function prepNonBlind(callback) {
                    if (self.isBlindUpload()) {
                        return callback(null);
                    }

                    //
                    //  For non-blind uploads, batch is not supported, we expect a single file
                    //  in |recvFilePaths|. If not, it's an error (we don't want to process the wrong thing)
                    //
                    if (self.recvFilePaths.length > 1) {
                        self.client.log.warn(
                            { recvFilePaths: self.recvFilePaths },
                            'Non-blind upload received 2:n files'
                        );
                        return callback(
                            Errors.UnexpectedState(
                                `Non-blind upload expected single file but got received ${self.recvFilePaths.length}`
                            )
                        );
                    }

                    return callback(null);
                },
                function scan(callback) {
                    return self.scanFiles(callback);
                },
                function pause(scanResults, callback) {
                    if (self.hasProcessingArt) {
                        self.client.term.rawWrite(
                            ansiGoto(self.client.term.termHeight, 1)
                        );
                    } else {
                        self.client.term.write('\n');
                    }

                    self.pausePrompt(() => {
                        return callback(null, scanResults);
                    });
                },
                function displayDupes(scanResults, callback) {
                    if (0 === scanResults.dupes.length) {
                        return callback(null, scanResults);
                    }

                    return self.displayDupesPage(scanResults.dupes, () => {
                        return callback(null, scanResults);
                    });
                },
                function prepDetails(scanResults, callback) {
                    return self.prepDetailsForUpload(scanResults, callback);
                },
                function startMovingAndPersistingToDatabase(scanResults, callback) {
                    //
                    //  *Start* the process of moving files from their current |tempRecvDirectory|
                    //  locations -> their final area destinations. Don't make the user wait
                    //  here as I/O can take quite a bit of time. Log any failures.
                    //
                    self.moveAndPersistUploadsToDatabase(scanResults.newEntries);
                    return callback(null, scanResults.newEntries);
                },
                function sendEvent(uploadedEntries, callback) {
                    Events.emit(Events.getSystemEvents().UserUpload, {
                        user: self.client.user,
                        files: uploadedEntries,
                    });
                    return callback(null);
                },
            ],
            err => {
                if (err) {
                    self.client.log.warn('File upload error encountered', {
                        error: err.message,
                    });
                    self.cleanupTempFiles(); //  normally called after moveAndPersistUploadsToDatabase() is completed.
                }

                return self.prevMenu();
            }
        );
    }

    displayOptionsPage(cb) {
        const self = this;

        async.series(
            [
                function prepArtAndViewController(callback) {
                    return self.prepViewControllerWithArt(
                        'options',
                        FormIds.options,
                        { clearScreen: true, trailingLF: false },
                        callback
                    );
                },
                function populateViews(callback) {
                    const areaSelectView = self.viewControllers.options.getView(
                        MciViewIds.options.area
                    );
                    areaSelectView.setItems(
                        self.availAreas.map(areaInfo => areaInfo.name)
                    );

                    const uploadTypeView = self.viewControllers.options.getView(
                        MciViewIds.options.uploadType
                    );
                    const fileNameView = self.viewControllers.options.getView(
                        MciViewIds.options.fileName
                    );

                    const blindFileNameText =
                        self.menuConfig.config.blindFileNameText ||
                        '(blind - filename ignored)';

                    uploadTypeView.on('index update', idx => {
                        self.uploadType = 0 === idx ? 'blind' : 'non-blind';

                        if (self.isBlindUpload()) {
                            fileNameView.setText(blindFileNameText);
                            fileNameView.acceptsFocus = false;
                        } else {
                            fileNameView.clearText();
                            fileNameView.acceptsFocus = true;
                        }
                    });

                    //  sanatize filename for display when leaving the view
                    self.viewControllers.options.on('leave', prevView => {
                        if (prevView.id === MciViewIds.options.fileName) {
                            fileNameView.setText(
                                sanatizeFilename(fileNameView.getData())
                            );
                        }
                    });

                    self.uploadType = 'blind';
                    uploadTypeView.setFocusItemIndex(0); //  default to blind
                    fileNameView.setText(blindFileNameText);
                    areaSelectView.redraw();

                    return callback(null);
                },
            ],
            err => {
                if (cb) {
                    return cb(err);
                }
            }
        );
    }

    displayProcessingPage(cb) {
        return this.prepViewControllerWithArt(
            'processing',
            FormIds.processing,
            { clearScreen: true, trailingLF: false },
            err => {
                //  note: this art is not required
                this.hasProcessingArt = !err;

                return cb(null);
            }
        );
    }

    fileEntryHasDetectedDesc(fileEntry) {
        return fileEntry.desc && fileEntry.desc.length > 0;
    }

    displayFileDetailsPageForUploadEntry(fileEntry, cb) {
        const self = this;

        async.waterfall(
            [
                function prepArtAndViewController(callback) {
                    return self.prepViewControllerWithArt(
                        'fileDetails',
                        FormIds.fileDetails,
                        { clearScreen: true, trailingLF: false },
                        err => {
                            return callback(err);
                        }
                    );
                },
                function populateViews(callback) {
                    const descView = self.viewControllers.fileDetails.getView(
                        MciViewIds.fileDetails.desc
                    );
                    const tagsView = self.viewControllers.fileDetails.getView(
                        MciViewIds.fileDetails.tags
                    );
                    const yearView = self.viewControllers.fileDetails.getView(
                        MciViewIds.fileDetails.estYear
                    );

                    self.updateCustomViewTextsWithFilter(
                        'fileDetails',
                        MciViewIds.fileDetails.customRangeStart,
                        fileEntry
                    );

                    tagsView.setText(Array.from(fileEntry.hashTags).join(',')); //  :TODO: optional 'hashTagsSep' like file list/browse
                    yearView.setText(fileEntry.meta.est_release_year || '');

                    if (isAnsi(fileEntry.desc)) {
                        fileEntry.descIsAnsi = true;

                        return descView.setAnsi(
                            fileEntry.desc,
                            {
                                prepped: false,
                                forceLineTerm: true,
                            },
                            () => {
                                return callback(
                                    null,
                                    descView,
                                    'preview',
                                    MciViewIds.fileDetails.tags
                                );
                            }
                        );
                    } else {
                        const hasDesc = self.fileEntryHasDetectedDesc(fileEntry);
                        descView.setText(
                            hasDesc
                                ? fileEntry.desc
                                : getDescFromFileName(fileEntry.fileName),
                            { scrollMode: 'top' } //  override scroll mode; we want to be @ top
                        );
                        return callback(
                            null,
                            descView,
                            'edit',
                            hasDesc
                                ? MciViewIds.fileDetails.tags
                                : MciViewIds.fileDetails.desc
                        );
                    }
                },
                function finalizeViews(descView, descViewMode, focusId, callback) {
                    descView.setPropertyValue('mode', descViewMode);
                    descView.acceptsFocus = 'preview' === descViewMode ? false : true;
                    self.viewControllers.fileDetails.switchFocus(focusId);
                    return callback(null);
                },
            ],
            err => {
                //
                //  we only call |cb| here if there is an error
                //  else, wait for the current from to be submit - then call -
                //  this way we'll move on to the next file entry when ready
                //
                if (err) {
                    return cb(err);
                }

                self.fileDetailsCurrentEntrySubmitCallback = cb; //  stash for moduleMethods.fileDetailsContinue
            }
        );
    }
};
