import { FolderInfo, IFolderInfo, IFileInfo, FileRestService, FileOldSystemRestService } from 'isogd-file-rest';
import * as _ from "lodash";
import * as angular from "angular";
import { INavFolderInfo } from '../../../models/NavFolderInfo';
import { INavItem } from '../../../models/INavItem';
import { DocumentRestService } from 'isogd-document-rest';

class NavigatorController {
  private folderInfo: FolderInfo;
  private myBlockUI: any;
  private document: any;
  private registry: any;
  private navFolderInfo: INavFolderInfo;
  private selected: INavFolderInfo | IFileInfo;
  private navigation: INavItem[] = [];
  private fileIsOpened = false;
  private fileContent: any;
  private extPattern: string = "";
  private extensions: string[];
  private classFile: string;
  private code: string;
  private availableExtensions: string[] = ['csv', 'doc', 'docx', 'dwg', 'jpg', 'jpeg', 'pdf', 'png', 'rar', 'sig', 'tiff', 'tif', 'txt', 'xml', 'zip'];
  private showBtnCreate: boolean = false;
  private showBtnCreateFolder: boolean = false;
  private isUploaded: boolean;
  private editor: boolean;
  private isOld: boolean;
  static $inject = ['fileRestService', 'fileOldSystemRestService', 'toastr', '$state', '$sce', 'blockUI', '$uibModal', '$timeout', 'documentRestService'];
  constructor(private fileRestService: FileRestService, private fileOldSystemRestService: FileOldSystemRestService, private toastr: Toastr,
    private $state: ng.ui.IStateService,
    private $sce: ng.ISCEService, private blockUI: any,
    private $uibModal: angular.ui.bootstrap.IModalService, private $timeout: ng.ITimeoutService, private documentRestService: DocumentRestService) {
  }

  $onInit() {
    this.myBlockUI = this.blockUI.instances.get('folderLoad');
    this.showBtnCreate = (this.folderInfo.folders.length === 0 && this.folderInfo.files.length === 0 && this.code === '8400');
    this.navFolderInfo = this.buildNavFolderInfo(this.folderInfo);
    this.navFolderInfo.loaded = true;
    this.navigation.push({
      id: this.navFolderInfo.folderId,
      name: this.navFolderInfo.folderName
    });
    this.selected = this.navFolderInfo;
    this.extensions.forEach((e, i) => {
      this.extPattern += e;
      if (i < this.extensions.length - 1)
        this.extPattern += ", "
    });
  }

  buildNavFolderInfo(folderInfo: FolderInfo): INavFolderInfo {
    let result: INavFolderInfo = <any>folderInfo;
    result.loaded = false;
    if (folderInfo.folders && folderInfo.folders.length > 0) {
      folderInfo.folders.forEach((f, i) => {
        result.folders[i].loaded = false;
      });
    }
    return result;
  }

  createFolderStructure() {
    let modalInstance = this.$uibModal.open({
      template: require('./selectObjectType.html'),
      controller: 'SelectObjectTypeController as ctrl',
      backdrop: 'static',
      keyboard: false,
      size: "md"
    });
    modalInstance.result.then((result: string) => {
      this.myBlockUI.start();
      this.fileRestService.createTreeStructure(this.folderInfo.folderId, result).then(response => {
        this.toastr.success("Структура каталогов успешно создана!");
        this.myBlockUI.stop();
        this.$state.reload();
      }).catch(error => {
        this.toastr.error("Ошибка при создании структуры каталогов!");
        this.myBlockUI.stop();
      });
    }).catch(error => {

    });
  }

  openFolder(folderInfo: INavFolderInfo) {
    if (!folderInfo.loaded) {
      this.myBlockUI.start();

      let promise: ng.IPromise<FolderInfo>;

      if (this.isOld) {
        promise = this.fileOldSystemRestService.filesTreeOld(folderInfo.folderId, "1levels")
      } else {
        promise = this.fileRestService.filesTree(folderInfo.folderId, "1level")
      }

      promise.then(response => {
        folderInfo.folders = this.buildNavFolderInfo(response).folders;
        folderInfo.files = response.files;
        folderInfo.loaded = true;
        this.myBlockUI.stop();
        this.navigation.push({
          id: folderInfo.folderId,
          name: folderInfo.folderName
        });
        this.selected = folderInfo;
        this.fileIsOpened = false;
      }).catch(error => {
        this.myBlockUI.stop();
        console.log(error);
      });
    } else if (folderInfo.loaded === true) {
      this.navigation.push({
        id: folderInfo.folderId,
        name: folderInfo.folderName
      });
      this.selected = folderInfo;
      this.fileIsOpened = false;
    }
  }
  open(id: string, index: number) {
    this.navigation.splice(_.findIndex(this.navigation, (n => {
      return n.id === id;
    })) + 1);
    this.selected = this.findFolder(this.navFolderInfo, id);
    this.fileIsOpened = false;
  }

  findFolder(folder: INavFolderInfo, id: string): INavFolderInfo {
    let result = null;
    if (folder.folderId === id) {
      result = folder;
    } else {
      if (folder.folders && folder.folders.length > 0) {
        for (let i = 0; i < folder.folders.length; i++) {
          let _result = this.findFolder(folder.folders[i], id);
          if (_result !== null) {
            result = _result;
          }
        }
      }
    }
    return result;
  }

  openFile(id: string) {
    var url = this.$state.href('viewFile', { id: id });
    window.open(url, '_blank');
  }

  $onDestroy() {
    this.myBlockUI.reset();
  }

  private serial(promisesFn: any[]): ng.IPromise<any> {
    let prevPromise = null;
    angular.forEach(promisesFn, (pFn) => {
      if (prevPromise === null) {
        prevPromise = pFn();
      } else {
        prevPromise = prevPromise.then(pFn);
      }
    });

    return prevPromise;
  }

  upload(files: File[]): void {
    if (this.classFile === undefined || this.classFile === null || this.classFile === "") {
      this.toastr.error("Не указан класс файла!");
      return;
    }

    let extPattern = this.extPattern.split(',');
    if (files && files.length) {

      let promises: any[] = [];

      for (let i = 0; i < files.length; i++) {
        let fileExtension = files[i].name.split('.').pop();
        let correctExtension: boolean = false;
        this.availableExtensions.forEach(ex => {
          if (ex === fileExtension)
            correctExtension = true;
        });
        if (!correctExtension)
          fileExtension = "unknown";
        if (fileExtension === "sig") {
          let arr: string[] = files[i].name.split('.');
          let fileExtension = arr[arr.length - 2];
        }
        let isAllowableFile: boolean = false;
        extPattern.forEach(t => {
          let ext = t.trim();
          if (fileExtension === ext) {
            isAllowableFile = true;
          }
        });

        if (extPattern.length > 0 && !isAllowableFile) {
          this.toastr.warning('Файл: ' + files[i].name + " имеет недопустимое расширение!");
        }

        let fd = new FormData();
        let _file = files[i];
        fd.append('file', _file);

        if (this.selected.folderId) {
          fd.append('folderGuid', this.selected.folderId);
        }

        if (this.classFile) {
          fd.append('fileType', this.classFile);
        }

        if (isAllowableFile) {
          promises.push(() => {
            return  this.fileRestService.handleFileUpload(fd); 
          });
        }
      }
      if (promises.length > 0) {
        this.isUploaded = true;
        this.serial(promises).then(response => {
          this.toastr.success((promises.length === 1) ? 'Файл успешно загружен!' : 'Файлы успешно загружены!');
          this.isUploaded = false;
          
          let promise: any;
          if (this.isOld) {
            promise = this.fileOldSystemRestService.filesTreeOld(this.selected.folderId, "1levels")
          } else {
            promise = this.fileRestService.filesTree(this.selected.folderId, "1level")
          }
    
          promise.then(response => {
            this.isUploaded = false;
            (<any>this.selected).files = response.files;
            this.fileIsOpened = false;
          }).catch(error => {
            this.toastr.error(((promises.length === 1) ? 'Ошибка при загрузке файла: ' : 'Ошибка при загрузке файлов: ') + error.status);
            this.isUploaded = false;
          });


        }).catch(error => {
          this.toastr.error(((promises.length === 1) ? 'Ошибка при загрузке файла: ' : 'Ошибка при загрузке файлов: ') + error.status);
          this.isUploaded = false;
        });
      }
    }
  }
}

export const folderNavigator: angular.IComponentOptions = {
  controller: NavigatorController,
  template: require('./navigator.html'),
  bindings: {
    folderInfo: '<',
    extensions: '<',
    classFile: '<',
    code: '<',
    editor: '<',
    isOld: '<',
    document: '<',
    registry: '<'
  }
};