//** REQUEST TYPES **//
export const REQUEST_TYPE_POST = "POST";
export const REQUEST_TYPE_GET = "GET";
export const REQUEST_TYPE_PUT = "PUT";
export const REQUEST_TYPE_DELETE = "DELETE";
//** POST CONTENT TYPES **//
export const CONTENT_TYPE_JSON = "json";
export const CONTENT_TYPE_FORM = "x-www-form-urlencoded";
//** API URLS **//
export const API_STATUS = "/api/v1/status";
export const API_INIT = "/api/v1/init";
export const API_RESTORE = "/api/v1/restore";
export const API_GET_SECRET = "/api/v1/get-secret";
export const API_RESET_PASS = "/api/v1/reset-password";
export const API_CREATE_BACKUP = "/api/v1/backup";
export const API_DOWNLOAD_BACKUP = "/api/v1/backup/download";
export const API_RESTORE_BACKUP = "/api/v1/backup/restore";
export const API_UPLOAD_AVATAR = "/api/v1/settings/add-avatar";
export const API_UPLOAD_BACKGROUND = "/api/v1/settings/add-feature-background";
export const API_IMAGE_UPLOAD = "/api/v1/page/add-entry-image";
//** API TASKS **//
export const TASK_SITE_INIT = "blogInit";
export const TASK_BACKUP_RESTORE = "restoreBackup";
export const TASK_BACKUP_CREATE = "createBackup";
export const TASK_GET_SECRET = "retrieveSecret";
export const TASK_RESET_PASS = "resetPassword";
export const TASK_UPLOAD_FILES = "uploadFiles";
//** API STATUS **//
export const API_ACCESS_GOOD = "apiUseAuthorized";
export const API_ACCESS_BAD = "apiUseNotAuthorized";

/**
 * A tub of methods for creating/restoring installs, resetting passwords and uploading images.
 */
class MaintenanceManager {
  /**
   * @constructor
   * @param {string} baseURL - url of site; uses local when empty
   * @param {string} key - user api key
   */
  constructor(baseURL = null, key = null) {
    this.percentComplete = 0; //for later
    this.token = null;
    this.baseURL = null;
    this.key = null;
    if (key) this.key = key;
    if (baseURL) this.baseURL = baseURL;
    //if key is valid, checks to see if a session is active and returns
    this._request(
      this.baseURL
        ? this.baseURL + API_STATUS + "?key=" + this.key
        : API_STATUS + "?key=" + this.key
    ).then((response) => {
      if (response.type === API_ACCESS_GOOD) {
        this.token = response.token;
      } else {
        //don't set token
        //console.log("NO TOKEN");
      }
    });
  }

  /**
   * Promise method used create new site from scratch. For local use only.
   * @param {object} data - json object that contains data for set up
   * @property {string} new_member_handle - handle for new user
   * @property {string} new_member_email - email for new user
   * @property {string} new_member_pass - password for new user
   * @property {string} new_member_title - title for new user
   */
  create(data) {
    return new Promise((resolve, reject) => {
      this._request(
        API_INIT,
        TASK_SITE_INIT,
        REQUEST_TYPE_POST,
        CONTENT_TYPE_JSON,
        data
      )
        .then((result) => {
          resolve(result);
        })
        .catch((err) => {
          reject(err);
        });
    });
  }
  /**
   * Promise method for restoring site from a previous back up. For local use only.
   * @param {object} form - form object that contains restore data and files
   * @property {string} restore_member_handle - handle for site user
   * @property {string} restore_member_pass - password for site user
   * @property {file} backup-upload - backup zip file
   */
  restore(form) {
    return new Promise((resolve, reject) => {
      var url, event, method, type, data;

      url = API_RESTORE;
      event = TASK_BACKUP_RESTORE;
      method = REQUEST_TYPE_POST;
      type = CONTENT_TYPE_FORM;
      data = new FormData(form);
      this._request(url, event, method, type, data)
        .then((result) => {
          resolve(result);
        })
        .catch((err) => {
          reject(err);
        });
    });
  }
  /**
   * Promise method for creating a zip back up of current site. For local use only.
   */

  backup() {
    return new Promise((resolve, reject) => {
      var url, event, method, type, data;

      url = API_CREATE_BACKUP;
      event = TASK_BACKUP_CREATE;
      method = REQUEST_TYPE_POST;
      type = CONTENT_TYPE_JSON;
      data = { task: "create_backup" };

      this._request(url, event, method, type, data)
        .then((result) => {
          resolve(result);
        })
        .catch((err) => {
          reject(err);
        });
    });
  }

  /**
   * Promise method for retrieving user secret key. For local use only.
   * @param {object} data - json object that contains data for set up
   * @property {string} email - email for site user
   */

  secret(data) {
    return new Promise((resolve, reject) => {
      this._request(
        API_GET_SECRET,
        TASK_GET_SECRET,
        REQUEST_TYPE_POST,
        CONTENT_TYPE_JSON,
        data
      )
        .then((result) => {
          resolve(result);
        })
        .catch((err) => {
          reject(err);
        });
    });
  }
  /**
   * Promise method for resetting password for user. For local use only.
   * @param {object} data - json object that contains data for set up
   * @property {string} new_password - password for user
   * @property {string} new_password2 - confirm password for user
   * @property {string} secret - secret key for user
   */

  newPass(data) {
    return new Promise((resolve, reject) => {
      this._request(
        API_RESET_PASS,
        TASK_RESET_PASS,
        REQUEST_TYPE_POST,
        CONTENT_TYPE_JSON,
        data
      )
        .then((result) => {
          resolve(result);
        })
        .catch((err) => {
          reject(err);
        });
    });
  }

  /**
   * Promise method for uploading images [todo: change to uploading files]
   * @param {string} type - type of upload
   * @param {input} files - form input containing files
   */
  imageUpload(type, files) {
    return new Promise((resolve, reject) => {
      let url = "";
      switch (type) {
        case "avatar-upload":
          url = API_UPLOAD_AVATAR;
          break;
        case "background-upload":
          url = API_UPLOAD_BACKGROUND;
          break;
        default:
          url = API_IMAGE_UPLOAD;
          break;
      }
      var imageData = new FormData();

      if (this.baseURL) {
        imageData.append("key", this.key);
        imageData.append("remote", true);
      } else {
        imageData.append("remote", false);
      }

      for (var i = 0; i < files.length; i++) {
        var file = files[i];
        // Check the file type.
        if (!file.type.match("image.*")) {
          continue;
        }
        if (type === "avatar-upload") {
          imageData.append("avatar_upload", file, file.name);
        } else if (type === "background-upload") {
          imageData.append("background_upload", file, file.name);
        } else {
          imageData.append("post_image", file, file.name);
        }
      }
      this._request(
        url,
        TASK_UPLOAD_FILES,
        REQUEST_TYPE_POST,
        CONTENT_TYPE_FORM,
        imageData
      )
        .then((r) => {
          resolve(r);
        })
        .catch((err) => {
          reject(err);
        });
    });
  }

  //--------------------------
  // private
  //--------------------------
  _request(
    requestURL,
    eventType,
    requestType = REQUEST_TYPE_GET,
    contentType = CONTENT_TYPE_JSON,
    requestData = null
  ) {
    var self = this;
    return new Promise(function (resolve, reject) {
      var request = new XMLHttpRequest();
      request.upload.onprogress = self.handleLoadProgress;
      request.open(requestType, requestURL, true);
      request.onload = () => {
        if (request.status == 200) {
          let response = JSON.parse(request["response"]);
          resolve(response);
        } else {
          let error = JSON.parse(request["response"]);
          reject(error);
        }
      };
      if (requestType == REQUEST_TYPE_PUT || requestType == REQUEST_TYPE_POST) {
        if (eventType === TASK_UPLOAD_FILES)
          request.setRequestHeader("fipamo-access-token", self.token);
        switch (contentType) {
          case CONTENT_TYPE_JSON:
            request.setRequestHeader(
              "Content-type",
              "application/" + contentType
            );
            request.send(JSON.stringify(requestData));
            break;
          case CONTENT_TYPE_FORM:
            request.send(requestData);
            break;
        }
      } else {
        request.send();
      }
    });
  }

  //--------------------------
  // event handlers
  //--------------------------
  handleLoadProgress(e) {
    this.percentComplete = Math.ceil((e.loaded / e.total) * 100);
    //pass element to display request progress
  }
}

export { MaintenanceManager as default };
