/**
 * Helper functions.
 *
 * @module
 * @private
 */

const gdal = require('gdal-async')
const fs = require('fs')
const { DownloaderHelper } = require('node-downloader-helper')
const csv = require('csv-parser')
const arcgis = require('@esri/arcgis-rest-feature-service')
const path = require('path')
const crypto = require('crypto')
const XLSX = require('xlsx')
const AdmZip = require('adm-zip')
const xpath = require('xpath')
const xmldom = require('xmldom')

/**
 * Common geometry field names.
 *
 * @property {string[]} wkt - Field names for well-known-text (WKT)
 * @property {string[]} lon - Field names for longitude
 * @property {string[]} lat - Field names for latitude
 * @property {string[]} x - Field names for x (longitude, easting)
 * @property {string[]} y - Field names for y (latitude, northing)
 */
const GEOMETRY_FIELDS = {
  wkt: [
    'geom', 'the_geom', 'wkb_geometry', 'shape', 'geo_shape', 'geometrie',
    'geometry'
  ],
  lon: [
    'longitude', 'lon', 'lng', 'long', 'x_long', 'coord long'
  ],
  lat: [
    'latitude', 'lat', 'y_lat', 'coord lat'
  ],
  x: [
    'x', 'x_koordina', 'x-koordinate', 'x_coord', 'coordenada x', 'xcoord',
    'easting', 'east', 'e', 'point_x'
  ],
  y: [
    'y', 'y_koordina', 'y-koordinate', 'y_coord', 'coordenada y', 'ycoord',
    'northing', 'north', 'n', 'point_y'
  ]
}

/**
 * Common file extensions for vector datasets.
 *
 * @property {string[]} 1 - Primary file extensions (take precedence)
 * @property {string[]} 2 - Secondary file extensions
 */
const FILE_EXTENSIONS = {
  1: ['geojson', 'geojsonl', 'topojson', 'shp', 'vrt', 'gml', 'kml'],
  2: ['csv', 'json']
}

/**
 * Regular expressions matching vector file extensions supported by GDAL.
 *
 * @property {RegExp} any - Matches any supported file extension
 * @property {RegExp} primary - Matches primary file extensions
 * @property {RegExp} secondary - Matches secondary file extensions
 */
const gdalFilePatterns = {
  any: new RegExp(`\\.(${getGdalExtensions().join('|')})$`, 'i'),
  primary: new RegExp(`\\.(${FILE_EXTENSIONS[1].join('|')})$`, 'i'),
  secondary: new RegExp(`\\.(${FILE_EXTENSIONS[2].join('|')})$`, 'i')
}

/**
 * Convert GDAL list to string.
 *
 * @param {Array} list - Array
 * @returns {string} List as a pipe-delimited string
 */
function listToString(list) {
  return list.join('|')
}

/**
 * String formatters by GDAL field type.
 */
const gdalStringFormatters = {
  [gdal.OFTDate]: dateToString,
  [gdal.OFTTime]: timeToString,
  [gdal.OFTDateTime]: datetimeToString,
  [gdal.OFTRealList]: listToString,
  [gdal.OFTIntegerList]: listToString,
  [gdal.OFTInteger64List]: listToString,
  [gdal.OFTStringList]: listToString,
  [gdal.OFTWideStringList]: listToString
}

/**
 * Format a date object as a string.
 *
 * Formats a date as `YYYY-MM-DD`, `YYYY-MM`, or `YYYY`.
 * See https://en.wikipedia.org/wiki/ISO_8601.
 *
 * @param {object} obj - Date
 * @param {integer} obj.year - Year (e.g. `2020`)
 * @param {integer} [obj.month] - Month (`1`-`12`)
 * @param {integer} [obj.day] - Day of the month (`1`-`31`)
 * @returns {string} ISO 8601 date
 */
function dateToString(obj) {
  if (!obj) return ''
  const yyyy = obj.year.toString().padStart(4, '0')
  if (!obj.month) return `${yyyy}`
  const mm = obj.month.toString().padStart(2, '0')
  if (!obj.day) return `${yyyy}-${mm}`
  const dd = obj.day.toString().padStart(2, '0')
  return `${yyyy}-${mm}-${dd}`
}

/**
 * Format a time object as string.
 *
 * Formats a time as `hh:mm:ss.*`.
 * See https://en.wikipedia.org/wiki/ISO_8601.
 *
 * @param {object} obj - Time
 * @param {integer} [obj.hour=0] - Hour (`0` - `23`)
 * @param {integer} [obj.minute=0] - Minute (`0` - `59`)
 * @param {number} [obj.second=0] - Second (`0` - `59.*`)
 * @returns {string} ISO 8601 time
 */
function timeToString(obj) {
  if (!obj) return ''
  const hh = (obj.hour || 0).toString().padStart(2, '0')
  const mm = (obj.minute || 0).toString().padStart(2, '0')
  const ssms = (obj.second || 0).toString().split('.')
  const ss = ssms[0].padStart(2, '0')
  const ms = ssms[1] ? `.${ssms[1]}` : ''
  return `${hh}:${mm}:${ss}${ms}`
}

/**
 * Format a GDAL timezone flag as a string.
 *
 * Formats a GDAL timezone flag as `''` (unknown), `Z` (UTC), or `[+-]hh:mm`.
 * See https://en.wikipedia.org/wiki/ISO_8601.
 *
 * @param {integer} [timezone=0] - GDAL timezone flag
 * @returns {string} ISO 8601 timezone
 */
function gdalTimezoneToString(timezone = 0) {
  // TZFlag: 0=unknown, 1=ambiguous, 100=GMT, 104=GMT+1, 80=GMT-5
  // See https://gdal.org/development/rfc/rfc56_millisecond_precision.html
  const min = timezone > 1 ? (timezone - 100) * 15 : null
  const hh = Math.floor(Math.abs(min) / 60).toString().padStart(2, '0')
  const mm = (Math.abs(min) % 60).toString().padStart(2, '0')
  return min ? `${min > 0 ? '+' : '-'}${hh}:${mm}` : (min == 0 ? 'Z' : '')
}

/**
 * Format a datetime object as a string.
 *
 * Formats a datetime as `YYYY-MM-DDThh:mm:ss.*` and the appropriate timezone.
 * See https://en.wikipedia.org/wiki/ISO_8601.
 *
 * @param {object} obj - Datetime
 * @param {integer} obj.year - Year (e.g. `2020`)
 * @param {integer} obj.month - Month (`1`-`12`)
 * @param {integer} obj.day - Day of the month (`1`-`31`)
 * @param {integer} [obj.hour=0] - Hour (`0` - `23`)
 * @param {integer} [obj.minute=0] - Minute (`0` - `59`)
 * @param {number} [obj.second=0] - Second (`0` - `59.*`)
 * @param {integer} [obj.timezone=0] - Timezone flag
 * @param {boolean} [truncate=false] - Whether to return only date when hour,
 * minute, and second are all zero.
 * @param {boolean} [gdalTimezone=true] - Whether `obj.timezone` is a GDAL
 * timezone flag (see {@link gdalTimezoneToString}) or already formatted as
 * an ISO 8601 timezone.
 * @returns {string} ISO 8601 datetime
 */
function datetimeToString(obj, truncate = false, gdalTimezone = true) {
  if (!obj) return ''
  const date = dateToString(obj)
  if (truncate && !(obj.hour || obj.minute || obj.second)) {
    return date
  }
  const time = timeToString(obj)
  let timezone
  if (gdalTimezone) {
    timezone = gdalTimezoneToString(obj.timezone)
  } else {
    timezone = obj.timezone || ''
  }
  return `${date}T${time}${timezone}`
}

/**
 * Reformat a datetime string as an ISO 8601 string.
 *
 * Reformats a datetime string as `YYYY-MM-DDThh:mm:ss.*` and the appropriate
 * timezone. See https://en.wikipedia.org/wiki/ISO_8601.
 *
 * @param {string} x - Datetime string
 * @param {RegExp[]} patterns - Regular expressions with capture groups
 * with names from the following list: `year`, `month`, `day`, `hour`, `minute`,
 * `second`, `timezone`. Returns result from first matching pattern.
 * @returns {string} ISO 8601 datetime
 */
function reformatDatetime(x, patterns) {
  // Skip if already parsed to object by gdal
  if (!x || typeof x === 'object') return x
  x = x.trim()
  for (const pattern of patterns) {
    const matches = x.match(pattern)
    if (matches) {
      return datetimeToString(
        matches.groups, truncate = true, gdalTimezone = false)
    }
  }
  console.warn('Failed to parse datetime:', x)
  return x
}

/**
 * Map object properties to a schema iteratively.
 *
 * @param {object} obj - Object
 * @param {object|object[]} mapping - Either a single mapping or an array
 * of mappings applied iteratively.
 * @param {object} [mapping.crosswalk={}] - Schema crosswalk. Each key is a new
 * property name and each value is either the original property name (string) or
 * a function called as f(obj).
 * @param {boolean} [mapping.keep=false] - Whether to keep original object
 * properties
 * @param {string} [mapping.prefix=''] - String to append to original property
 * names
 * @returns {object} Mapped object
 */
function mapObject(obj, mapping) {
  let final = obj
  if (!Array.isArray(mapping)) mapping = [mapping]
  for (const { crosswalk = {}, keep, prefix = '' } of mapping) {
    const current = {}
    if (keep) {
      for (const key in final) {
        current[`${prefix}${key}`] = final[key]
      }
    }
    for (const key in crosswalk) {
      current[key] = (typeof crosswalk[key] === 'function') ?
        crosswalk[key](final) : final[crosswalk[key]]
    }
    final = current
  }
  return final
}

/**
 * Guess feature layer geometry fields based on their name.
 *
 * @param {gdal.Layer} layer - Feature layer
 * @returns {object[]} Names of fields with potential WKT geometry (wkt),
 * geographic coordinates (lon, lat), or geographic or projected coordinates (x,
 * y).
 */
function guessGeometryFields(layer) {
  const geometry = {}
  const names = layer.fields.getNames()
  Object.keys(GEOMETRY_FIELDS).forEach(key => {
    geometry[key] = names.filter(x =>
      GEOMETRY_FIELDS[key].includes(x.toLowerCase()))
  })
  return geometry
}

/**
 * Get the list of vector file extensions supported by GDAL.
 *
 * @returns {string[]} File extensions
 */
function getGdalExtensions() {
  const extensions = []
  gdal.drivers.forEach(driver => {
    const meta = driver.getMetadata()
    if (meta.DCAP_VECTOR === 'YES') {
      if (meta.DMD_EXTENSION) extensions.push(meta.DMD_EXTENSION)
      if (meta.DMD_EXTENSIONS) extensions.push(...meta.DMD_EXTENSIONS.split(' '))
    }
  })
  return [...new Set(extensions.sort())]
}

/**
 * Get the list of GDAL driver names assigned to each file extension.
 *
 * @returns {object} GDAL driver names by file extension
 */
function getGdalDrivers() {
  const drivers = {}
  getGdalExtensions().forEach(extension => drivers[extension] = [])
  gdal.drivers.forEach(driver => {
    const meta = driver.getMetadata()
    if (meta.DCAP_VECTOR === 'YES') {
      const extensions = []
      if (meta.DMD_EXTENSION) {
        extensions.push(meta.DMD_EXTENSION)
      }
      if (meta.DMD_EXTENSIONS) {
        extensions.push(...meta.DMD_EXTENSIONS.split(' '))
      }
      [...new Set(extensions)].forEach(extension =>
        drivers[extension].push(driver.description.toLowerCase()))
    }
  })
  return drivers
}

/**
 * Get the file extension from a local or remote file path.
 *
 * @param {string} file - Local or remote file path
 * @returns {string} File extension
 */
function getFileExtension(file) {
  const matches = file.match(/\.([^\.\/\?\#]+)(?:$|\?|\#)/)
  return matches ? matches[1] : ''
}

/**
 * Get the transformation between two spatial reference systems (SRS).
 *
 * @param {string|gdal.SpatialReference} source - Source SRS
 * @param {string|gdal.SpatialReference} target - Target SRS
 * @returns {gdal.CoordinateTransformation|undefined} Coordinate transformation,
 * or undefined if the two SRS are equal.
 */
function getTransform(source, target) {
  if (typeof source === 'string') {
    source = gdal.SpatialReference.fromUserInput(source)
  }
  if (typeof target === 'string') {
    target = gdal.SpatialReference.fromUserInput(target)
  }
  // NOTE: Only sure way to test for equality is to test the transformation
  const same = source.isSame(target) ||
    (source.isSameGeogCS(target) && !source.isProjected() && !target.isProjected())
  const sameAxes = isAxesXY(source) === isAxesXY(target)
  if (!(same && sameAxes)) {
    return new gdal.CoordinateTransformation(source, target)
  }
}

/**
 * Build the GDAL polygon corresponding to a bounding box.
 *
 * @param {number[]} bounds - Bounding box [xmin, ymin, xmax, ymax]
 * @param {string|gdal.SpatialReference} [srs] - Spatial reference system
 * @returns {gdal.Polygon}
 */
function boundsToPolygon(bounds, srs) {
  if (typeof srs === 'string') {
    srs = gdal.SpatialReference.fromUserInput(srs)
  }
  const polygon = new gdal.Polygon()
  const ring = new gdal.LinearRing()
  ring.points.add(new gdal.Point(bounds[0], bounds[1]))
  ring.points.add(new gdal.Point(bounds[0], bounds[3]))
  ring.points.add(new gdal.Point(bounds[2], bounds[3]))
  ring.points.add(new gdal.Point(bounds[2], bounds[1]))
  ring.points.add(new gdal.Point(bounds[0], bounds[1]))
  polygon.rings.add(ring)
  polygon.srs = srs
  return polygon
}

/**
 * Check whether spatial reference system has x (east), y (north) axis order.
 *
 * @param {string|gdal.SpatialReference} srs - Spatial reference system
 */
function isAxesXY(srs) {
  if (typeof srs === 'string') {
    srs = gdal.SpatialReference.fromUserInput(srs)
  }
  wkt = srs.toWKT()
  xi = wkt.match(/axis\[[^\]]*(east|west|longitude)[^\]]*\]/i)
  yi = wkt.match(/axis\[[^\]]*(north|south|latitude)[^\]]*\]/i)
  if (xi && xi) {
    return xi.index < yi.index
  } else {
    // NOTE: Assumes x, y axis order if axes not defined
    return true
  }
}

/**
 * Determine whether geometry x, y has swapped axes relative to a target.
 *
 * @param {number[]} xy - Coordinates x, y.
 * @param {number[]} targetXY - Target coordinates x, y.
 * @returns {boolean} Whether x, y has swapped axes relative to target x, y.
 */
function hasSwappedAxes(xy, targetXY) {
  return (
    (Math.abs(xy[0] - targetXY[0]) > Math.abs(xy[0] - targetXY[1])) ||
    (Math.abs(xy[1] - targetXY[1]) > Math.abs(xy[1] - targetXY[0]))
  )
}

/**
 * Download a remote file to a directory.
 *
 * @param {string} url - Path to the remote file.
 * @param {string} dir - Local directory to download the file to.
 * @param {object} options - Downloader Helper constructor options (see
 * https://github.com/hgouveia/node-downloader-helper#options.
 * @param {object} listeners - Downloader Helper event listeners (see
 * https://github.com/hgouveia/node-downloader-helper#events).
 * @returns {Promise<string>} Resolves to the path of the downloaded file.
 */
async function downloadFile(url, dir, options = {}, listeners = {}) {
  fs.mkdirSync(dir, { recursive: true })
  const downloader = new DownloaderHelper(url, dir, options)
  let failure
  listeners = {
    download: info => console.log(`Downloading ${info.fileName}`),
    end: info => console.log(
      `Downloaded ${info.fileName} (${(info.downloadedSize / 1e6).toFixed()} MB)`
    ),
    error: error => console.error(`Download failed for ${url}: ${error.message}`),
    ...listeners
  }
  for (const key in listeners) {
    if (key != 'error') {
      downloader.on(key, listeners[key])
    }
  }
  downloader.on('error', error => {
    const attempt = downloader.__retryCount + 1
    const attempts = options.retry ? options.retry.maxRetries + 1 : 1
    if (attempt === attempts) {
      failure = error
    }
  })
  try {
    await downloader.start()
  } catch (error) {
    failure = error
  }
  if (failure) {
    listeners.error(failure)
  } else {
    return downloader.getDownloadPath()
  }
}

/**
 * Read a CSV file.
 *
 * Uses `csv-parser`, which is faster than GDAL.
 *
 * @param {string} file - Path to file.
 * @param {object} options - Parse options
 * (https://www.npmjs.com/package/csv-parser#options).
 * @returns {Promise<object[]>}
 */
function readCSV(file, options) {
  return new Promise((resolve, reject) => {
    const rows = []
    fs.createReadStream(file).
      pipe(csv(options)).
      on('data', (row) => {
        rows.push(row)
      }).
      on('end', () => {
        console.log(`${file} successfully parsed`)
        resolve(rows)
      }).
      on('error', reject)
  })
}

/**
 * Write a CSV file.
 *
 * Converts values to string and wraps strings containing commas in quotes.
 * Objects need not contain the same properties, nor in the same order.
 *
 * @param {object[]} objects – Objects to write to a CSV file.
 * @param {string} [file=null] – Path to file.
 * @returns {string|null} CSV as a string (if `file` is `null`).
 * @example
 * objects = [ { x: 1 }, { y: 2 }, { x: 3, y: 3, z: 'foo,bar' } ]
 * writeCSV(objects)
 * // 'x,y,z\n1,,\n,2,\n3,3,"foo,bar"'
 */
function writeCSV(objects, file = null) {
  const columnSet = new Set()
  // Load unique column names
  objects.forEach(obj => {
    Object.keys(obj).forEach(columnSet.add, columnSet)
  })
  const columns = [...columnSet]
  // Generate header
  const header = columns.map(x => {
    return (typeof (x) === 'string' && x.includes(',')) ? `"${x}"` : String(x)
  }).join(',')
  // Generate rows
  const rows = objects.map(obj => {
    return columns.map(key => {
      const x = obj[key]
      const type = typeof x
      if (x == null || (type === 'number' && isNaN(x))) {
        return ''
      }
      return (type === 'string' && x.includes(',')) ? `"${x}"` : String(x)
    }).join(',')
  })
  // Combine
  const txt = [header, ...rows].join('\n')
  if (file) {
    fs.mkdirSync(path.dirname(file), { recursive: true })
    fs.writeFileSync(file, [header, ...rows].join('\n'))
  } else {
    return txt
  }
}

/**
 * Convert string to sentence case.
 *
 * Capitalizes the first character and converts the rest to lower case.
 *
 * @param {string} s
 * @returns {string}
 * @example
 * toSentenceCase('') // ''
 * toSentenceCase('m') // 'M'
 * toSentenceCase('malus') // 'Malus'
 * toSentenceCase('malus pumila') // 'Malus pumila'
 */
function toSentenceCase(s) {
  return s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase()
}

/**
 * Convert string to title case.
 *
 * Capitalizes the first character of every word and converts the rest to lower case.
 *
 * @param {*} s
 * @example
 * toTitleCase('') // ''
 * toTitleCase('m') // 'M'
 * toTitleCase('malus') // 'Malus'
 * toTitleCase('GOLDEN DELICIOUS') // 'Golden Delicious'
 */
function toTitleCase(s) {
  return s.replace(
    /(\w)(\w*)/g,
    (_, firstChar, remainder) => firstChar.toUpperCase() + remainder.toLowerCase()
  )
}

const ASCII = {
  A: 'AⒶＡÀÁÂẦẤẪẨÃĀĂẰẮẴẲȦǠÄǞẢÅǺǍȀȂẠẬẶḀĄȺⱯ',
  AA: 'Ꜳ',
  AE: 'ÆǼǢ',
  AO: 'Ꜵ',
  AU: 'Ꜷ',
  AV: 'ꜸꜺ',
  AY: 'Ꜽ',
  B: 'BⒷＢḂḄḆɃƂƁ',
  C: 'CⒸＣĆĈĊČÇḈƇȻ',
  D: 'DⒹＤḊĎḌḐḒḎĐƋƊƉ',
  DZ: 'DZDŽ',
  Dz: 'DzDž',
  E: 'EⒺＥÈÉÊỀẾỄỂẼĒḔḖĔĖËẺĚȄȆẸỆȨḜĘḘḚƐƎ',
  F: 'FⒻＦḞƑ',
  G: 'GⒼＧǴĜḠĞĠǦĢǤƓꞠ',
  H: 'HⒽＨĤḢḦȞḤḨḪĦⱧ',
  I: 'IⒾＩÌÍÎĨĪĬİÏḮỈǏȈȊỊĮḬƗ',
  J: 'JⒿＪĴ',
  K: 'KⓀＫḰǨḲĶḴƘⱩꝀꝂꝄꞢ',
  L: 'LⓁＬĿĹĽḶḸĻḼḺŁȽⱢⱠꝈ',
  LJ: 'LJ',
  Lj: 'Lj',
  M: 'MⓂＭḾṀṂƜ',
  N: 'NⓃＮǸŃÑṄŇṆŅṊṈȠƝꞐꞤ',
  NJ: 'NJ',
  Nj: 'Nj',
  O: 'OⓄＯÒÓÔỒỐỖỔÕṌȬṎŌṐṒŎȮȰÖȪỎŐǑȌȎƠỜỚỠỞỢỌỘǪǬØǾƆƟꝊꝌ',
  OE: 'Œ',
  OI: 'Ƣ',
  OO: 'Ꝏ',
  OU: 'Ȣ',
  P: 'PⓅＰṔṖƤⱣꝐꝒꝔ',
  Q: 'QⓆＱꝖꝘ',
  R: 'RⓇＲŔṘŘȐȒṚṜŖṞɌⱤꝚꞦ',
  S: 'SⓈＳẞŚṤŜṠŠṦṢṨȘŞⱾꞨ',
  T: 'TⓉＴṪŤṬȚŢṰṮŦƬƮȾ',
  TZ: 'Ꜩ',
  U: 'UⓊＵÙÚÛŨṸŪṺŬÜǛǗǕǙỦŮŰǓȔȖƯỪỨỮỬỰỤṲŲṶṴɄ',
  V: 'VⓋＶṼṾƲꝞɅ',
  VY: 'Ꝡ',
  W: 'WⓌＷẀẂŴẆẄẈⱲ',
  X: 'XⓍＸẊẌ',
  Y: 'YⓎＹỲÝŶỸȲẎŸỶỴƳɎỾ',
  Z: 'ZⓏＺŹẐŻŽẒẔƵȤⱿⱫꝢ',
  a: 'aⓐａẚàáâầấẫẩãāăằắẵẳȧǡäǟảåǻǎȁȃạậặḁąⱥɐꜳ',
  ae: 'æǽǣ',
  ao: 'ꜵ',
  au: 'ꜷ',
  av: 'ꜹꜻ',
  ay: 'ꜽ',
  b: 'bⓑｂḃḅḇƀƃɓ',
  c: 'cⓒｃćĉċčçḉƈȼ',
  d: 'dⓓｄḋďḍḑḓḏđƌɖɗꝺð',
  dz: 'dzdž',
  e: 'eⓔｅèéêềếễểẽēḕḗĕėëẻěȅȇẹệȩḝęḙḛɇɛǝ',
  f: 'fⓕｆḟƒ',
  g: 'gⓖｇǵĝḡğġǧģǥɠꞡᵹ',
  h: 'hⓗｈĥḣḧȟḥḩḫẖħⱨɥ',
  hv: 'ƕ',
  i: 'iⓘｉìíîĩīĭïḯỉǐȉȋịįḭɨı',
  j: 'jⓙｊĵǰɉ',
  k: 'kⓚｋḱǩḳķḵƙⱪꝁꝃꝅꞣ',
  l: 'lⓛｌŀĺľḷḹļḽḻłƚɫ',
  lj: 'lj',
  m: 'mⓜｍḿṁṃɱɯᶆ',
  n: 'nⓝｎǹńñṅňṇņṋṉƞɲʼnꞑꞥ',
  nj: 'nj',
  o: 'oⓞｏòóôồốỗổõṍȭṏōṑṓŏȯȱöȫỏőǒȍȏơờớỡởợọộǫǭøǿɔꝋꝍɵ',
  oe: 'œ',
  oi: 'ƣ',
  ou: 'ȣ',
  oo: 'ꝏ',
  p: 'pⓟｐṕṗƥᵽꝑꝓꝕ',
  q: 'qⓠｑɋꝗꝙ',
  r: 'rⓡｒŕṙřȑȓṛṝŗṟɍɽ',
  s: 'sⓢｓśṥŝṡšṧṣṩșşȿꞩẛſß',
  t: 'tⓣｔṫẗťṭțţṱṯŧƭʈⱦ',
  tz: 'ꜩ',
  u: 'uⓤｕùúûũṹūṻŭüǜǘǖǚủůűǔȕȗưừứữửựụṳųṷṵʉ',
  v: 'vⓥｖṽṿʋꝟʌ',
  w: 'wⓦｗẁẃŵẇẅẘẉⱳ',
  x: 'xⓧẋẍxᶍｘ',
  y: 'yⓨｙỳýŷỹȳẏÿỷẙỵƴɏỿ',
  z: 'zⓩｚźẑżžẓẕƶȥɀⱬ'
}

const ASCII_MAP = {}
for (const key in ASCII) {
  for (const letter of ASCII[key]) {
    ASCII_MAP[letter] = key
  }
}

/**
 * Latinize a string.
 *
 * Converts accents (diacritics, etc) to latin characters.
 *
 * @param {string} s - String.
 * @param {string} keep - Characters to preserve.
 * @returns {string}
 * @example
 * latinize('Leœptura') // 'Leoeptura'
 * latinize('Ærenea') // 'AErenea'
 * latinize('Fallén') // 'Fallen'
 * latinize('Choriozopella') // 'Choriozopella'
 * latinize('trägårdhi') // 'tragardhi'
 * latinize('rosa-sinensis') // 'rosa-sinensis'
 * latinize('ỆᶍǍᶆṔƚÉ áéíóúýčďěňřšťžů') // 'ExAmPlE aeiouycdenrstzu'
 */
function latinize(s, keep = 'ｘ') {
  return s.replace(/[^\u0000-\u007E]/g, x => keep.includes(x) ? x : ASCII_MAP[x] || x)
}

/**
 * Interpolate string as template with values from object.
 *
 * @param {string} x - String to interpolate
 * @param {object} obj - Object with properties to use for interpolation
 * @example
 * interpolateString('data/${id}/${id}/input', {id: 'melbourne'})
 * interpolateString('data/${ids}/input', {id: 'melbourne'})
 */
function interpolateString(x, obj) {
  let ix = x
  let match
  while ((match = ix.match(/\$\{([^\}]*)\}/))) {
    ix = ix.replace(match[0], obj[match[1]])
  }
  return ix
}

/**
 * Convert string to lowercase and remove whitespace.
 *
 * @param {string} x - String to reduce
 * @example
 * reduceString('United Kingdom')
 */
function reduceString(x) {
  return x.toLowerCase().replace(/\s/, '')
}

/**
 * Pause code execution.
 *
 * @param {number} ms - Number of milliseconds to pause.
 * @returns {Promise}
 */
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms))
}

/**
 * Get features from ArcGIS Feature Server layer.
 *
 * Features are queried as EPSG:4326 EsriJSON sorted by object ID.
 *
 * @see https://developers.arcgis.com/rest/services-reference/query-feature-service-layer-.htm
 *
 * @param {string} url - URL of ArcGIS Feature Server layer.
 * @returns {Promise<object>} Layer features.
 */
async function getLayerFeatures(url) {
  // Get layer metadata
  const layer = await arcgis.getLayer({url: url, f: 'json'})
  // Verify that layer can be queried
  const capabilities = layer.capabilities.toLowerCase().split(/,\s?/)
  if (!capabilities.includes('query')) {
    throw new Error('Layer does not support queries')
  }
  const queryFormats = layer.supportedQueryFormats.toLowerCase().split(/,\s?/)
  if (!queryFormats.includes('json')) {
    throw new Error('Layer does not support JSON queries')
  }
  // Whether layer supports pagination
  const pagination = layer.advancedQueryCapabilities?.supportsPagination === true
  // Whether layer supports 'standard' result type
  const standard = (
    layer.advancedQueryCapabilities?.supportsQueryWithResultType === true &&
    layer.standardMaxRecordCount > layer.maxRecordCount
  )
  // Cap record count to a reasonable maximum
  const count = Math.min(
    (standard ? layer.standardMaxRecordCount : layer.maxRecordCount), 20000
  )
  // Order by object ID field
  let orderByField = layer.objectIdField
  if (!orderByField) {
    for (const field of layer.fields) {
      if (field.type.toLowerCase() === 'esrifieldtypeoid') {
        orderByField = field.name
        break
      }
    }
  }
  if (!orderByField) {
    throw new Error('Layer does not have an object ID field')
  }
  // Get layer features
  let exceededTransferLimit = true
  let offset = 0
  let result
  while (exceededTransferLimit) {
    console.log(`Downloading features (${url}): ${offset} – ...`)
    const response = await arcgis.queryFeatures({
      // HACK: For servers requring a where clause
      where: '1=1',
      url: url,
      f: 'json',
      outFields: '*',
      orderByFields: orderByField,
      outSR: { wkid: 4326 },
      resultType: standard ? 'standard' : 'none',
      ...(pagination ? {resultOffset: offset, resultRecordCount: count} : {}),
    })
    if (result) {
      result.features.push(...response.features)
    } else {
      result = response
    }
    exceededTransferLimit = (
      response.exceededTransferLimit === true ||
      response.properties?.exceededTransferLimit === true
    )
    if (exceededTransferLimit) {
      if (pagination) {
        offset += response.features.length
        await sleep(2000)
      } else {
        throw new Error('Layer transfer limit exceeded')
      }
    }
  }
  return result
}

/**
 * Write values as newline-delimited JSON.
 *
 * References:
 * - https://www.interline.io/blog/geojsonl-extracts
 * - https://jsonlines.org
 * - https://stevage.github.io/ndgeojson
 *
 * @param {Array} values Values to independently write as JSON.
 * @param {string} [file=null] Path to file.
 * @returns {string|null} JSON Lines as a string (if `file` is `null`).
 * @example
 * values = [ 1, ['b'], { x: null } ]
 * writeJSONL(values) // '1\n["b"]\n{"x":null}'
 */
function writeJSONL(values, file = null) {
  const txt = values.map(JSON.stringify).join('\n')
  if (file) {
    fs.mkdirSync(path.dirname(file), { recursive: true })
    fs.writeFileSync(file, txt)
  } else {
    return txt
  }
}

/**
 * Read newline-delimited JSON.
 *
 * @param {string} file - Path to file.
 * @returns {object}
 */
function readJSONL(file) {
  return fs.readFileSync(file, 'utf8').split('\n').filter(x => x).map(JSON.parse)
}

/**
 * Read newline-delimited JSON line by line.
 *
 * @param {string} file - Path to file.
 * @yields {object}
 */
async function* iterateJSONL(file) {
  const readInterface = readline.createInterface({
    input: fs.createReadStream(file),
  })
  for await (const line of readInterface) {
    if (line.trim() === '') {
      continue
    }
    try {
      yield JSON.parse(line)
    } catch (error) {
      console.error(`Error parsing as JSON: '${line}'\n${error.message}`)
    }
  }
}

/**
 * Read file from ZIP archive.
 *
 * @param {string} zipfile - Path to zip file.
 * @param {string} file - Path to file inside zip file.
 * @returns {Buffer}
 */
function readFileInZip(zipfile, file) {
  const zip = new AdmZip(zipfile)
  return zip.readFile(file)
}

/**
 * Open Excel-compatible file with GDAL.
 *
 * Uses `xlsx` because bundled GDAL (gdal-async) does not support
 * XLS, XLSX, and CSV with custom separator.
 *
 * @param {Buffer|string} data – File data.
 * @param {object} options
 * @param {string} [options.type] – File type (buffer, file).
 * @param {integer} [options.sheet=0] – Sheet index or name.
 * @returns {gdal.Dataset}
 */
function openExcelWithGdal(data, {type, sheet = 0} = {}) {
  const book = XLSX.read(data, {type, sheets: sheet})
  const txt = XLSX.utils.sheet_to_csv(book.Sheets[book.SheetNames[sheet]])
  const buffer = Buffer.from(txt)
  const name = crypto.randomBytes(6).toString('hex')
  gdal.vsimem.set(buffer, `/vsimem/${name}.csv`)
  return gdal.open(`/vsimem/${name}.csv`)
}

/**
 * Read all files in a RAR archive to GDAL VSIMEM.
 *
 * @param {string} rarfile - Path to RAR file.
 * @returns {string[]} Paths to files in GDAL VSIMEM.
 */
async function readFilesInRarToVsimem(file) {
  // HACK: Import unrar here to prevent it from making program exit on error
  const unrar = require('node-unrar-js')
  const buffer = Uint8Array.from(fs.readFileSync(file)).buffer
  const extractor = await unrar.createExtractorFromData({data: buffer})
  const extracted = extractor.extract()
  const rarFiles = [...extracted.files]
  const vsiFiles = []
  for (const rarFile of rarFiles) {
    if (rarFile.extraction) {
      const vsiFile = path.join('/vsimem/', file, rarFile.fileHeader.name)
      gdal.vsimem.set(Buffer.from(rarFile.extraction), vsiFile)
      vsiFiles.push(vsiFile)
    }
  }
  return vsiFiles
}

/**
 * Open files in GDAL as a single layer (using VRT union).
 *
 * @param {string[]} files - Paths to files.
 * @returns {gdal.Dataset}
 */
function openFileUnionWithGdal(files) {
  let vrt = '<OGRVRTDataSource><OGRVRTUnionLayer name="union">'
  for (const file of files) {
    vrt += `<OGRVRTLayer name="${path.parse(file).name}">
      <SrcDataSource>${file}</SrcDataSource>
    </OGRVRTLayer>`
  }
  vrt += '</OGRVRTUnionLayer></OGRVRTDataSource>'
  const name = crypto.randomBytes(6).toString('hex')
  gdal.vsimem.set(Buffer.from(vrt, 'utf8'), `/vsimem/${name}.vrt`)
  return gdal.open(`/vsimem/${name}.vrt`)
}

/**
 * Open a KISSB XML file with GDAL.
 *
 * See https://www.carneios.de/kissb/pdf/Spezifikation_Katasteraustauschformat.pdf
 * Fields with objects as values are flattened using dot notation.
 *
 * @param {string|Buffer} file - Path to file or buffer.
 * @param {object} params
 * @param {string} [params.type=file] - File type (file, buffer).
 * @returns {gdal.Dataset}
 */
function openKissbXmlWithGdal(file, {type = 'file'} = {}) {
  // Read from file or buffer
  let xml
  if (type === 'buffer') {
    xml = file.toString('utf8')
  } else {
    xml = fs.readFileSync(file, 'utf8')
  }
  const parser = new xmldom.DOMParser()
  const tree = parser.parseFromString(xml)
  // Extract field (property) names by id
  const fieldNames = {}
  const properties = xpath.select(
    "//*[name()='configuration']//*[name()='property']",
    tree
  )
  properties.forEach(property => {
    const id = xpath.select("*[name()='id']", property)?.[0].firstChild.data
    const name = xpath.select("*[name()='name']", property)?.[0].firstChild.data
    if (id && name) {
      fieldNames[id] = name
    }
  })
  // Extract features (protocols)
  const protocols = xpath.select("//*[name()='data']/*[name()='protocol']", tree)
  const features = protocols.map(protocol => {
    const fields = xpath.select("*/*", protocol)
    const feature = {}
    for (const field of fields) {
      const fieldName = fieldNames[field.nodeName]
      const children = field.childNodes
      if (children.length === 0) {
        // Empty: <field/>
        continue
      } else if (children.length === 1) {
        // Text value: <field>Berlin</field>
        const value = children[0].data
        if (value) {
          feature[fieldName] = value
        }
      } else {
        // Children: <field><genus>Salix</genus><type>alba</type></field>
        for (const child of Object.values(children)) {
          const name = child.nodeName
          if (name !== '#text') {
            const value = child.firstChild?.data
            if (value) {
              feature[`${fieldName}.${name}`] = value
            }
          }
        }
      }
    }
    return feature
  })
  // HACK: Write features as CSV and open with GDAL
  const txt = writeCSV(features)
  const name = crypto.randomBytes(6).toString('hex')
  gdal.vsimem.set(Buffer.from(txt, 'utf8'), `/vsimem/${name}.csv`)
  return gdal.open(`/vsimem/${name}.csv`)
}

/**
 * Read ESRI Feature Collection to GDAL VSIMEM as ESRIJSON.
 *
 * @param {string} file - Path to file.
 * @param {object} params
 * @param {string} [params.layerName] - Layer name.
 * @returns {string} Path to VSIMEM file.
 */
function readEsriFeatureCollectionToVsimem(file, {layerName} = {}) {
  const data = JSON.parse(fs.readFileSync(file, 'utf8'))
  let layerNames
  let layers
  // Find layers
  if (data.operationalLayers) {
    layers = data.operationalLayers
    layerNames = data.operationalLayers.map(x => x.id)
  } else if (data.layers) {
    layers = data.layers
    layerNames = layers.map(x => x.layerDefinition?.name)
  } else {
    throw new Error('No layers or operationalLayers property')
  }
  // Select layer
  let layerIndex
  if (layers.length == 0) {
    throw new Error('Empty (operational)layers property')
  }
  if (layers.length == 1) {
    layerIndex = 0
  } else {
    if (!layerName) {
      throw new Error(`Multiple layers found: ${layerNames}`)
    }
    if (!layerNames.includes(layerName)) {
      throw new Error(`Layer '${layerName}' not found in ${layerNames}`)
    }
    layerIndex = layerNames.indexOf(layerName)
  }
  // Load layer
  let layer
  if (data.operationalLayers) {
    layers = data.operationalLayers[layerIndex].featureCollection?.layers
    if (!layers) {
      throw new Error('No layers found inside operational layer')
    }
    if (layers.length > 1) {
      layerNames = layers.map(x => x.layerDefinition?.name)
      throw new Error(`Multiple layers inside operational layer: ${layerNames}`)
    }
    layer = layers[0]
  } else {
    layer = data.layers[layerIndex]
  }
  // Verify layer
  if (!layer.featureSet?.features) {
    throw new Error('No features found')
  }
  if (!layer.layerDefinition) {
    throw new Error('No layer definition found')
  }
  const esrijson = {
    objectIdFieldName: layer.layerDefinition.objectIdField,
    geometryType: layer.layerDefinition.geometryType || layer.featureSet.geometryType,
    spatialReference: layer.layerDefinition.spatialReference,
    fields: layer.layerDefinition.fields,
    features: layer.featureSet.features,
  }
  // HACK: Write features as ESRIJSON
  const txt = JSON.stringify(esrijson)
  const name = crypto.randomBytes(6).toString('hex')
  const vsimem = `/vsimem/${name}.json`
  gdal.vsimem.set(Buffer.from(txt, 'utf8'), vsimem)
  return vsimem
}

/**
 * Open ESRI Feature Collection with GDAL.
 *
 * @param {string} file - Path to file.
 * @param {object} params
 * @param {string} [params.layerName] - Layer name.
 * @returns {gdal.Dataset}
 */
function openEsriFeatureCollectionWithGdal(file, {layerName} = {}) {
  vsimem = readEsriFeatureCollectionToVsimem(file, {layerName})
  return gdal.open(`ESRIJSON:${vsimem}`)
}

/**
 * Parse decimal degrees from degrees, minutes, seconds.
 *
 * @param {string} dms - Degrees, minutes, seconds.
 * @param {RegExp} pattern - Regular expression with named capture groups deg,
 * min, sec.
 * @returns {number} Decimal degrees.
 */
function parseDecimalFromDMS(dms, pattern) {
  const match = dms.match(pattern)
  if (!match) {
    console.warn(`Failed to parse DMS: ${dms}`)
    return null
  }
  return (
    Number(match.groups.deg) +
    Number(match.groups.min) / 60 +
    Number(match.groups.sec) / 3600
  )
}

module.exports = {
  gdalFilePatterns,
  gdalStringFormatters,
  reformatDatetime,
  mapObject,
  guessGeometryFields,
  getGdalDrivers,
  getFileExtension,
  getTransform,
  boundsToPolygon,
  isAxesXY,
  hasSwappedAxes,
  downloadFile,
  readCSV,
  writeCSV,
  toSentenceCase,
  toTitleCase,
  latinize,
  interpolateString,
  reduceString,
  getLayerFeatures,
  writeJSONL,
  readJSONL,
  iterateJSONL,
  readFileInZip,
  openExcelWithGdal,
  readFilesInRarToVsimem,
  openFileUnionWithGdal,
  openKissbXmlWithGdal,
  readEsriFeatureCollectionToVsimem,
  openEsriFeatureCollectionWithGdal,
  parseDecimalFromDMS
}