/////////////////////////////////
// General utility library
//

const icons = {
  image: "$ayiFileImage",
  pdf: "$ayiFilePdf",
  word: "$ayiFileWord",
  powerpoint: "$ayiFilePowerpoint",
  excel: "$ayiFileExcel",
  csv: "$ayiFileCsv",
  audio: "$ayiFileAudio",
  video: "$ayiFileVidio",
  archive: "$ayiFileArchive",
  code: "$ayiFileCode",
  text: "$ayiFileAlt",
  file: "$ayiFile"
};
const mimeTypes = {
  "image/gif": icons.image,
  "image/jpeg": icons.image,
  "image/png": icons.image,
  "image/webp": icons.image,

  "application/pdf": icons.pdf,

  "application/msword": icons.word,
  "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
    icons.word,

  "application/mspowerpoint": icons.powerpoint,
  "application/vnd.openxmlformats-officedocument.presentationml.presentation":
    icons.powerpoint,

  "application/msexcel": icons.excel,
  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
    icons.excel,

  "text/csv": icons.csv,

  "audio/aac": icons.audio,
  "audio/wav": icons.audio,
  "audio/mpeg": icons.audio,
  "audio/mp4": icons.audio,
  "audio/ogg": icons.audio,

  "video/x-msvideo": icons.video,
  "video/mpeg": icons.video,
  "video/mp4": icons.video,
  "video/ogg": icons.video,
  "video/quicktime": icons.video,
  "video/webm": icons.video,

  "application/gzip": icons.archive,
  "application/zip": icons.archive,
  "application/x-tar": icons.archive,

  "text/css": icons.code,
  "text/html": icons.code,
  "text/javascript": icons.code,
  "application/javascript": icons.code,

  "text/plain": icons.text,
  "text/richtext": icons.text,
  "text/rtf": icons.text,
  "application/rtf": icons.text,
  "application/json": icons.text
};

const extensions = {
  gif: icons.image,
  jpeg: icons.image,
  jpg: icons.image,
  png: icons.image,
  webp: icons.image,

  pdf: icons.pdf,

  doc: icons.word,
  docx: icons.word,

  ppt: icons.powerpoint,
  pptx: icons.powerpoint,

  xls: icons.excel,
  xlsx: icons.excel,

  csv: icons.csv,

  aac: icons.audio,
  mp3: icons.audio,
  ogg: icons.audio,

  avi: icons.video,
  flv: icons.video,
  mkv: icons.video,
  mp4: icons.video,

  gz: icons.archive,
  zip: icons.archive,
  tar: icons.archive,
  "7z": icons.archive,

  css: icons.code,
  html: icons.code,
  js: icons.code,

  txt: icons.text,
  json: icons.text,
  rtf: icons.text
};

export default {
  ///////////////////////////////
  // CLEAN OBJECT
  // Clear all properties from object without resorting to assigning a new object (o={})
  // which can be problematic in some cases (IE bugs, watched data items in forms etc)

  removeAllPropertiesFromObject: function(o) {
    for (let variableKey in o) {
      if (Object.prototype.hasOwnProperty.call(o, variableKey)) {
        delete o[variableKey];
      }
    }
  },
  ///////////////////////////////
  // DEEP COPY FOR API UPDATE
  // Deep copy an object skipping all *Viz and named properties from object
  //
  deepCopySkip: function(source, skipNames) {
    if (skipNames == null) {
      skipNames = [];
    }
    let o = {};
    for (let key in source) {
      if (
        !key.endsWith("Viz") &&
        !skipNames.some(x => x == key) &&
        Object.prototype.hasOwnProperty.call(source, key)
      ) {
        o[key] = source[key];
      }
    }
    return o;
  },

  /**
   * Copy a string to clipboard
   * @param  {String} string         The string to be copied to clipboard
   * @return {Boolean}               returns a boolean correspondent to the success of the copy operation.
   * Modified from an example here: https://stackoverflow.com/a/53951634/8939
   * Basically a fallback if navigator.clipboard is not available
   */
  copyToClipboard: function(string) {
    let textarea;
    let result;

    if (navigator && navigator.clipboard) {
      navigator.clipboard.writeText(string);
    } else {
      try {
        textarea = document.createElement("textarea");
        textarea.setAttribute("readonly", true);
        textarea.setAttribute("contenteditable", true);
        textarea.style.position = "fixed"; // prevent scroll from jumping to the bottom when focus is set.
        textarea.value = string;

        document.body.appendChild(textarea);

        textarea.focus();
        textarea.select();

        const range = document.createRange();
        range.selectNodeContents(textarea);

        const sel = window.getSelection();
        sel.removeAllRanges();
        sel.addRange(range);

        textarea.setSelectionRange(0, textarea.value.length);
        result = document.execCommand("copy");
      } catch (err) {
        result = null;
      } finally {
        document.body.removeChild(textarea);
      }

      // manual copy fallback using prompt
      if (!result) {
        const isMac = navigator.platform.toUpperCase().indexOf("MAC") >= 0;
        const copyHotkey = isMac ? "⌘C" : "CTRL+C";
        result = prompt(`Press ${copyHotkey}`, string);
        if (!result) {
          return false;
        }
      }
    }
    return true;
  },
  ///////////////////////////////
  // ROUNDING
  // //https://medium.com/swlh/how-to-round-to-a-certain-number-of-decimal-places-in-javascript-ed74c471c1b8
  roundAccurately: function(number, decimalPlaces) {
    if (!number || number == 0 || Number.isNaN(number)) {
      return number;
    }
    const wasNegative = number < 0;
    if (wasNegative) {
      number = Math.abs(number); //make sure it's positive because rounding negative numbers is weird in JS
    }
    number = Number(
      Math.round(number + "e" + decimalPlaces) + "e-" + decimalPlaces
    );
    if (wasNegative) {
      number = 0 - number;
    }
    return number;
  },
  ///////////////////////////////
  // CLEAN TAG NAME
  // Clean up a tag with same rules as server
  //
  normalizeTag: function(tagName) {
    if (!tagName || tagName == "") {
      return null;
    }
    tagName = tagName.toLowerCase();

    //spaces to dashes
    tagName = tagName.replace(/ /gi, "-");

    //multiple dashes to single dashes
    tagName = tagName.replace(/-+/g, "-");

    //ensure doesn't start or end with a dash
    tagName = this.trimSpecific(tagName, "-");

    //No longer than 255 characters
    tagName = tagName.length > 255 ? tagName.substr(0, 255 - 1) : tagName;

    return tagName;
  },
  ///////////////////////////////
  // Quick hash for trivial purposes
  // not cryptographic
  // https://stackoverflow.com/a/7616484/8939
  //
  quickHash: function(theString) {
    let hash = 0;
    let i;
    let chr;
    if (theString.length === 0) return hash;
    for (i = 0; i < theString.length; i++) {
      chr = theString.charCodeAt(i);
      hash = (hash << 5) - hash + chr;
      hash |= 0; // Convert to 32bit integer
    }
    return hash;
  },

  ////////////////////////////////////////
  // Random password / login generator
  // https://stackoverflow.com/a/51540480/8939
  // using 32 character (128 bit) as default
  //
  getRandomPassword: function() {
    const wishlist = "0123456789abcdefghijkmnopqrstuvwxyz";

    return Array.from(crypto.getRandomValues(new Uint32Array(32)))
      .map(x => wishlist[x % wishlist.length])
      .join("");
  },
  ///////////////////////////////
  // CONVERT STRING TO BOOLEAN
  // https://stackoverflow.com/a/1414175/8939
  //
  stringToBoolean: function(string) {
    switch (string.toLowerCase().trim()) {
      case "true":
      case "yes":
      case "1":
        return true;
      case "false":
      case "no":
      case "0":
      case null:
        return false;
      default:
        return Boolean(string);
    }
  }, ///////////////////////////////
  // CONVERT STRING TO FLOAT
  // https://stackoverflow.com/a/9409894/8939
  //
  stringToFloat: function(string) {
    //null or empty then zero
    if (!string) {
      return 0;
    }

    //A number already then parse and return
    if (this.isNumeric(string)) {
      if (Number.isNaN(string)) {
        return 0;
      }
      return parseFloat(string);
    }

    //Not a string at all?
    if (!this.isString(string)) {
      return 0;
    }

    const ret = parseFloat(string.replace(/[^\d.-]/g, ""));
    if (Number.isNaN(ret)) {
      return 0;
    }

    return ret;
  },
  ///////////////////////////////
  // Is negative number
  //
  //
  isNegative: function(v) {
    //null or empty then zero
    if (!v || v == 0 || Number.isNaN(v)) {
      return false;
    }
    return parseFloat(v) < 0;
  },
  ///////////////////////////////
  // Splice a string
  //changes the content of a string by removing a range of
  // characters and/or adding new characters.
  //
  // @param {String} source string
  // @param {number} start Index at which to start changing the string.
  // @param {number} delCount An integer indicating the number of old chars to remove.
  // @param {string} newSubStr The String that is spliced in.
  // @return {string} A new string with the spliced substring.
  stringSplice: function(source, start, delCount, newSubStr) {
    if (source == null || source == "") {
      if (newSubStr) {
        return newSubStr;
      }
      return "";
    }
    return (
      source.slice(0, start) +
      newSubStr +
      source.slice(start + Math.abs(delCount))
    );
  },
  ///////////////////////////////
  // Truncate a string
  //truncates and adds ellipses
  //
  // @param {String} source string
  // @param {number} length desired
  // @return {string} A new string truncated with ellipses at end
  truncateString: function(s, len) {
    if (this.stringIsNullOrEmpty(s)) {
      return s;
    }
    if (s.length > len) {
      return s.substring(0, len) + "...";
    } else {
      return s;
    }
  },
  ///////////////////////////////
  // Format tags for display
  //
  //
  // @param {String} tags raw from server
  // @return {string} A new string with the tags formatted or an empty string if no tags
  formatTags: function(tags) {
    if (tags && tags.length > 0) {
      return tags.join(", ");
    }
    return "";
  },
  ///////////////////////////////
  // ICON FOR *ALL* OBJECT TYPES
  //(used for search results and event log / history)
  //NOTE: Any object type could appear in event log, they all need to be supported where possible
  //CoreBizObject add here
  iconForType: function(ayaType) {
    switch (ayaType) {
      case window.$gz.type.NoType:
      case null:
        return "$ayiGenderless";
      case window.$gz.type.Global:
        return "$ayiGlobe";
      case window.$gz.type.User:
        return "$ayiUser";
      case window.$gz.type.ServerState:
        return "$ayiDoorOpen";
      case window.$gz.type.License:
        return "$ayiTicket";
      case window.$gz.type.LogFile:
        return "$ayiGlasses";
      case window.$gz.type.PickListTemplate:
        return "$ayiPencilRuler";
      case window.$gz.type.Customer:
        return "$ayiAddressCard";
      case window.$gz.type.ServerJob:
        return "$ayiRobot";
      case window.$gz.type.Contract:
        return "$ayiFileContract";
      case window.$gz.type.TrialSeeder:
        return "$ayiSeedling";
      case window.$gz.type.Metrics:
        return "$ayiFileMedicalAlt";
      case window.$gz.type.Translation:
        return "$ayiLanguage";
      case window.$gz.type.UserOptions:
        return "$ayiUserCog";
      case window.$gz.type.HeadOffice:
        return "$ayiSitemap";
      case window.$gz.type.LoanUnit:
        return "$ayiPlug";
      case window.$gz.type.FileAttachment:
        return "$ayiPaperclip";
      case window.$gz.type.DataListSavedFilter:
        return "$ayiFilter";
      case window.$gz.type.FormCustom:
        return "$ayiCustomize";
      case window.$gz.type.Part:
        return "$ayiBoxes";
      case window.$gz.type.PartWarehouse:
        return "$ayiWarehouse";
      case window.$gz.type.PartAssembly:
        return "$ayiObjectGroup";
      case window.$gz.type.Project:
        return "$ayiProjectDiagram";
      case window.$gz.type.PurchaseOrder:
        return "$ayiTruckLoading";
      case window.$gz.type.Unit:
        return "$ayiFan";
      case window.$gz.type.UnitModel:
        return "$ayiDiceD20";
      case window.$gz.type.Vendor:
        return "$ayiStore";
      case window.$gz.type.Quote:
        return "$ayiPencilAlt";
      case window.$gz.type.PM:
        return "$ayiBusinessTime";
      case window.$gz.type.WorkOrder:
        return "$ayiTools";
      case window.$gz.type.WorkOrderItem:
      case window.$gz.type.PMItem:
      case window.$gz.type.QuoteItem:
        return "$ayiWrench";
      case window.$gz.type.WorkOrderItemExpense:
      case window.$gz.type.QuoteItemExpense:
      case window.$gz.type.PMItemExpense:
        return "$ayiMoneyBillWave";
      case window.$gz.type.WorkOrderItemLabor:
      case window.$gz.type.QuoteItemLabor:
      case window.$gz.type.PMItemLabor:
        return "$ayiHammer";
      case window.$gz.type.WorkOrderItemLoan:
      case window.$gz.type.QuoteItemLoan:
      case window.$gz.type.PMItemLoan:
        return "$ayiPlug";
      case window.$gz.type.WorkOrderItemPart:
      case window.$gz.type.QuoteItemPart:
      case window.$gz.type.PMItemPart:
        return "$ayiBoxes";
      case window.$gz.type.WorkOrderItemPartRequest:
        return "$ayiParachuteBox";
      case window.$gz.type.WorkOrderItemScheduledUser:
      case window.$gz.type.QuoteItemScheduledUser:
      case window.$gz.type.PMItemScheduledUser:
        return "$ayiUserClock";
      case window.$gz.type.WorkOrderItemTask:
      case window.$gz.type.QuoteItemTask:
      case window.$gz.type.PMItemTask:
      case window.$gz.type.TaskGroup:
        return "$ayiTasks";
      case window.$gz.type.WorkOrderItemTravel:
      case window.$gz.type.QuoteItemTravel:
      case window.$gz.type.PMItemTravel:
        return "$ayiTruckMonster";
      case window.$gz.type.WorkOrderItemUnit:
      case window.$gz.type.QuoteItemUnit:
      case window.$gz.type.PMItemUnit:
        return "$ayiFan";
      case window.$gz.type.WorkOrderItemOutsideService:
      case window.$gz.type.QuoteItemOutsideService:
      case window.$gz.type.PMItemOutsideService:
        return "$ayiLuggageCart";
      case window.$gz.type.Backup:
        return "$ayiFileArchive";
      case window.$gz.type.Notification:
        return "$ayiBell";
      case window.$gz.type.NotifySubscription:
        return "$ayiBullhorn";
      case window.$gz.type.Reminder:
        return "$ayiStickyNote";
      case window.$gz.type.UnitMeterReading:
        return "$ayiWeight";
      case window.$gz.type.CustomerServiceRequest:
        return "$ayiConciergeBell";
      // case window.$gz.type.ServiceBank:
      //   return "$ayiCarBattery";
      case window.$gz.type.OpsNotificationSettings:
        return "$ayiBullhorn";
      case window.$gz.type.Report:
        return "$ayiThList";
      case window.$gz.type.DashboardView:
        return "$ayiTachometer";
      case window.$gz.type.CustomerNote:
        return "$ayiClipboard";
      case window.$gz.type.Memo:
        return "$ayiInbox";
      case window.$gz.type.Review:
        return "$ayiCalendarCheck";
      case window.$gz.type.ServiceRate:
        return "$ayiCalculator";
      case window.$gz.type.TravelRate:
        return "$ayiCalculator";
      case window.$gz.type.TaxCode:
        return "$ayiPercent";
      case window.$gz.type.WorkOrderStatus:
        return "$ayiFlag";

      //scroll icon is good one for something
      default:
        return null;
    }
  },
  //https://gist.github.com/colemanw/9c9a12aae16a4bfe2678de86b661d922
  iconForFile: function(fileName, mimeType) {
    // List of official MIME Types: http://www.iana.org/assignments/media-types/media-types.xhtml

    let extension = null;
    if (fileName && fileName.includes(".")) {
      extension = fileName.split(".").pop();
      extension = extension.toLowerCase();
    }
    if (!extension && !mimeType) {
      console.log(
        "gzutil:iconForFile -> No mime or extension for " +
          fileName +
          " " +
          mimeType
      );
      return "$ayiFile";
    }

    if (!mimeType) {
      mimeType = "";
    }
    mimeType = mimeType.toLowerCase();

    const iconFromExtension = extensions[extension];
    const iconFromMIME = mimeTypes[mimeType];

    if (iconFromMIME) {
      return iconFromMIME;
    }
    if (iconFromExtension) {
      return iconFromExtension;
    }

    return "$ayiFile";
  },
  ///////////////////////////////////////////////
  // attempt to detect image extension name
  //
  isImageAttachment: function(fileName, mimeType) {
    return this.iconForFile(fileName, mimeType) == "$ayiFileImage";
  },
  ///////////////////////////////////////////////
  // Sleep async
  //
  sleepAsync: function(milliseconds) {
    // eslint-disable-next-line
    return new Promise((resolve) => setTimeout(resolve, milliseconds));
  },
  ///////////////////////////////////////////////
  // sortByKey lodash "sortBy" replacement
  // https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore#_sortby-and-_orderby
  //usage:
  // The native sort modifies the array in place. `_.orderBy` and `_.sortBy` do not, so we use `.concat()` to
  // copy the array, then sort.
  // fruits.concat().sort(sortBy("name"));
  // => [{name:"apple", amount: 4}, {name:"banana", amount: 2}, {name:"mango", amount: 1}, {name:"pineapple", amount: 2}]
  sortByKey: key => {
    return (a, b) => {
      const aaa = a[key].toUpperCase();
      const bbb = b[key].toUpperCase();
      return aaa > bbb ? 1 : bbb > aaa ? -1 : 0;
      //this was the original but it was sorting weird as it was taking case into account with uppercase higher than lowercase
      //so PMItem came before Part in the object lists
      //return a[key] > b[key] ? 1 : b[key] > a[key] ? -1 : 0;
    };
  },
  ///////////////////////////////////////////////
  // "has" lodash replacement
  // https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore#_has
  //
  has: function(obj, key) {
    var keyParts = key.split(".");
    return (
      !!obj &&
      (keyParts.length > 1
        ? this.has(obj[key.split(".")[0]], keyParts.slice(1).join("."))
        : hasOwnProperty.call(obj, key))
    );
  },
  ///////////////////////////////////////////////
  // Check if object is empty
  //
  objectIsEmpty: function(obj) {
    //https://stackoverflow.com/a/4994265/8939
    return !obj || Object.keys(obj).length === 0;
  },
  ///////////////////////////////////////////////
  // Trim specific character from start and end
  // https://stackoverflow.com/a/55292366/8939
  //
  trimSpecific: function trim(str, ch) {
    var start = 0;
    var end = str.length;
    while (start < end && str[start] === ch) ++start;
    while (end > start && str[end - 1] === ch) --end;
    return start > 0 || end < str.length ? str.substring(start, end) : str;
  },
  ///////////////////////////////////////////////
  // is numeric replacement for lodash
  // https://stackoverflow.com/a/52986361/8939
  //
  isNumeric: function(n) {
    //lodash isNumber returned false if it's a string and that's what the rest of the code expects even though it's parseable to a number
    return !this.isString(n) && !isNaN(parseFloat(n)) && isFinite(n);
  },
  ///////////////////////////////////////////////
  // is string replacement for lodash
  // https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore#_isString
  //
  isString: function(str) {
    return str != null && typeof str.valueOf() === "string";
  },
  ///////////////////////////////////////////////
  //
  //
  //
  stringIsNullOrEmpty: function(str) {
    if (str === null || str === undefined) {
      return true;
    }
    if (this.isString(str)) {
      if (str.trim() == "") {
        return true;
      }
    }
    return false;
  },
  ///////////////////////////////////////////////
  // is Boolean replacement for lodash
  // https://stackoverflow.com/a/43718478/8939
  //
  isBoolean: function(obj) {
    return obj === true || obj === false || typeof variable === "boolean";
  },
  ///////////////////////////////////////////////
  // parse to number or null if not a number
  // used because route params can turn into strings
  // on their own
  //
  stringToIntOrNull: function(n) {
    const ret = Number.parseInt(n, 10);
    if (Number.isNaN(ret)) {
      return null;
    }
    return ret;
  },
  ///////////////////////////////////////////////
  // Simple array equality comparison
  // (will NOT work on arrays of objects)
  // Array order is relevant here as they are not sorted
  // change of order will equal change of array
  // as this is required for datatable sortby
  //
  isEqualArraysOfPrimitives: function(a, b) {
    if (a === b) return true;
    if (a == null || b == null) return false;
    if (a.length !== b.length) return false;

    // If you don't care about the order of the elements inside
    // the array, you should sort both arrays here.
    // Please note that calling sort on an array will modify that array.
    // you might want to clone your array first.

    for (var i = 0; i < a.length; ++i) {
      if (a[i] !== b[i]) return false;
    }
    return true;
  },
  ///////////////////////////////////////////////
  // Use geolocation api to attempt to get current location
  // try high accuracy first and downgrade if unavailable
  //https://www.openstreetmap.org/?mlat=48.3911&mlon=-124.7353#map=12/48.3910/-124.7353
  //https://www.openstreetmap.org/#map=18/49.68155/-125.00435
  //https://www.openstreetmap.org/?mlat=49.71236&mlon=-124.96961#map=17/49.71236/-124.96961
  //https://www.google.com/maps/search/?api=1&query=47.5951518,-122.3316393
  getGeoLocation: async function() {
    return new Promise((resolve, reject) => {
      navigator.geolocation.getCurrentPosition(
        function successHigh(pos) {
          resolve({
            latitude: pos.coords.latitude,
            longitude: pos.coords.longitude
          });
        },
        function error(err) {
          //if here due to timeout getting high accuracy then try again with low accuracy
          if (error.code == error.TIMEOUT) {
            navigator.geolocation.getCurrentPosition(
              function successLow(pos) {
                resolve({
                  latitude: pos.coords.latitude,
                  longitude: pos.coords.longitude
                });
              },
              function error(err) {
                reject(
                  new Error(
                    `ERROR getting location(low_accuracy: ${err.code}): ${err.message}`
                  )
                );
              },
              { maximumAge: 600000, timeout: 10000, enableHighAccuracy: false }
            );
            return;
          }

          reject(
            new Error(
              `ERROR GETTING LOCATION(high_accuracy:${err.code}): ${err.message}`
            )
          );
        },
        { maximumAge: 600000, timeout: 5000, enableHighAccuracy: true }
      );
    });
  },
  ///////////////////////////////////////////////
  // Open map url
  //
  //
  viewGeoLocation: function(obj) {
    const hasGeo =
      obj.latitude != null &&
      obj.latitude != 0 &&
      obj.longitude != null &&
      obj.longitude != 0;

    const hasAddress =
      !this.stringIsNullOrEmpty(obj.address) &&
      !this.stringIsNullOrEmpty(obj.city) &&
      !this.stringIsNullOrEmpty(obj.region) &&
      !this.stringIsNullOrEmpty(obj.country) &&
      !this.stringIsNullOrEmpty(obj.postCode);

    if (!hasGeo && !hasAddress) {
      return;
    }

    let mapUrl = window.$gz.store.state.userOptions.mapUrlTemplate;

    //No pre-set?
    if (!mapUrl || mapUrl == "") {
      mapUrl =
        "https://www.google.com/maps/search/?api=1&query={ayaddress}<|>https://www.google.com/maps/search/?api=1&query={aylatitude},{aylongitude}";
    }

    let geoMapUrl = null;
    let addressMapUrl = null;

    //Parse the map url
    let mapUrls = [mapUrl];
    if (mapUrl.includes("<|>")) {
      mapUrls = mapUrl.split("<|>");
    }

    mapUrls.forEach(z => {
      if (!geoMapUrl && z.includes("{aylatitude}")) {
        geoMapUrl = z;
      }
      if (!addressMapUrl && z.includes("{ayaddress}")) {
        addressMapUrl = z;
      }
    });

    //decide which map to use here, favor geocode
    if (hasGeo && geoMapUrl) {
      //geo view
      mapUrl = geoMapUrl;
      mapUrl = mapUrl.split("{aylatitude}").join(obj.latitude);
      mapUrl = mapUrl.split("{aylongitude}").join(obj.longitude);
    } else if (hasAddress && addressMapUrl) {
      mapUrl = addressMapUrl;
      //compile address fields together
      //order street to country seems to be standard
      //note, if google need plus symbol delimiter, if bing, need comma delimiter
      //but both might accept one big string space delimited and url encoded so test that on all first
      const delimiter = " ";
      let q = "";
      if (obj.address) {
        q += obj.address + delimiter;
      }
      if (obj.city) {
        q += obj.city + delimiter;
      }

      if (obj.region) {
        q += obj.region + delimiter;
      }

      if (obj.country) {
        q += obj.country + delimiter;
      }

      if (obj.postCode) {
        q += obj.postCode + delimiter;
      }

      if (obj.addressPostal) {
        q += obj.addressPostal + delimiter;
      }

      if (q.length > 1) {
        q = q.substring(0, q.length - 1);
      }
      //url encode the query
      q = encodeURIComponent(q);
      mapUrl = mapUrl.split("{ayaddress}").join(q);
    } else {
      throw new Error(
        "View map: error - no matching mapurl / address / geo coordinates set for display, nothing to view"
      );
    }
    window.open(mapUrl, "map");
    //This is not valid to do as some platforms don't open a new web browser window
    //but rather a map application in which case this is null and throws up the exception even though it's working
    // if (window.open(mapUrl, "map") == null) {
    //   throw new Error(
    //     "Problem displaying map in new window.  Browser must allow pop-ups to view maps; check your browser setting"
    //   );
    // }
  },
  ///////////////////////////////////////////////
  // Online mapping service url formats
  //
  //
  mapProviderUrls: function() {
    return [
      {
        name: "Apple",
        value:
          "http://maps.apple.com/?q={ayaddress}<|>http://maps.apple.com/?ll={aylatitude},{aylongitude}"
      },
      {
        name: "Bing",
        value:
          "https://bing.com/maps/default.aspx?where1={ayaddress}<|>https://bing.com/maps/default.aspx?cp={aylatitude}~{aylongitude}&lvl=17&style=r&sp=point.{aylatitude}_{aylongitude}"
      },
      {
        name: "Google",
        value:
          "https://www.google.com/maps/search/?api=1&query={ayaddress}<|>https://www.google.com/maps/search/?api=1&query={aylatitude},{aylongitude}"
      },
      {
        name: "MapQuest",
        value:
          "https://mapquest.com/?center={ayaddress}&zoom=17<|>https://mapquest.com/?center={aylatitude},{aylongitude}&zoom=17"
      },
      {
        name: "Open Street Map",
        value:
          "https://www.openstreetmap.org/search?query={ayaddress}<|>https://www.openstreetmap.org/?mlat={aylatitude}&mlon={aylongitude}#map=17/{aylatitude}/{aylongitude}"
      },
      {
        name: "geo URI",
        value: "geo:{aylatitude},{aylongitude}"
      },
      {
        name: "Waze",
        value:
          "https://waze.com/ul?q={ayaddress}<|>https://www.waze.com/ul?ll={aylatitude},{aylongitude}&navigate=yes&zoom=17"
      },
      {
        name: "Yandex",
        value:
          "https://yandex.ru/maps/?mode=search&text={ayaddress}&z=17<|>https://yandex.ru/maps/?ll={aylatitude},{aylongitude}&z=12&l=map"
      }
    ];
  },
  ///////////////////////////////////////////////
  // v-calendar view to AyaNova scheduleview enum
  //
  //
  calendarViewToAyaNovaEnum: function(view) {
    switch (view) {
      case "day":
        return 1;
      case "week":
        return 2;
      case "month":
        return 3;
      case "4day":
        return 4;
      case "category":
        return 5;

      default:
        throw new Error(
          `gzutil->calendarViewtoAyaNovaEnum - Unknown view type '${view}'`
        );
    }
  },
  ///////////////////////////////////////////////
  // GZDaysOfWeek to VCalendar weekdays
  //
  //
  DaysOfWeekToWeekdays: function(dow) {
    /*
    AyaDaysOfWeek
  Monday = 1,
        Tuesday = 2,
        Wednesday = 4,
        Thursday = 8,
        Friday = 16,
        Saturday = 32,
        Sunday = 64

  vCalendar [
  0,//sunday
  1,
  2,
  3,
  4,
  5,
  6//saturday
]
 */
    if (dow == null || dow == 0) {
      return [0, 1, 2, 3, 4, 5, 6]; //all the days
    }
    const ret = [];

    //turn EXCLUDE selected gzDaysOfWeek into INCLUDE selected days for vCalendar
    if (!(dow & 64)) {
      ret.push(0);
    }
    if (!(dow & 1)) {
      ret.push(1);
    }
    if (!(dow & 2)) {
      ret.push(2);
    }
    if (!(dow & 4)) {
      ret.push(3);
    }
    if (!(dow & 8)) {
      ret.push(4);
    }
    if (!(dow & 16)) {
      ret.push(5);
    }
    if (!(dow & 32)) {
      ret.push(6);
    }
    return ret;
  },
  ///////////////////////////////////////////////
  // Random integer from 0 to max
  //
  //
  getRandomInt: function(max) {
    return Math.floor(Math.random() * max);
  }
  /**
   *
   *
   */

  //new functions above here
};