'use strict'

const warning = require('./deprecations')
const escapeValue = require('./utils/escape-value')
const isDottedDecimal = require('./utils/is-dotted-decimal')

/**
 * Implements a relative distinguished name as described in
 * https://www.rfc-editor.org/rfc/rfc4514.
 *
 * @example
 * const rdn = new RDN({cn: 'jdoe', givenName: 'John'})
 * rdn.toString() // 'cn=jdoe+givenName=John'
 */
class RDN {
  #attributes = new Map()

  /**
   * @param {object} rdn An object of key-values to use as RDN attribute
   * types and attribute values. Attribute values should be strings.
   */
  constructor (rdn = {}) {
    for (const [key, val] of Object.entries(rdn)) {
      this.setAttribute({ name: key, value: val })
    }
  }

  get [Symbol.toStringTag] () {
    return 'LdapRdn'
  }

  /**
   * The number attributes associated with the RDN.
   *
   * @returns {number}
   */
  get size () {
    return this.#attributes.size
  }

  /**
   * Very naive equality check against another RDN instance. In short, if they
   * do not have the exact same key names with the exact same values, then
   * this check will return `false`.
   *
   * @param {RDN} rdn
   *
   * @returns {boolean}
   *
   * @todo Should implement support for the attribute types listed in https://www.rfc-editor.org/rfc/rfc4514#section-3
   */
  equals (rdn) {
    if (Object.prototype.toString.call(rdn) !== '[object LdapRdn]') {
      return false
    }
    if (this.size !== rdn.size) {
      return false
    }

    for (const key of this.keys()) {
      if (rdn.has(key) === false) return false
      if (this.getValue(key) !== rdn.getValue(key)) return false
    }

    return true
  }

  /**
   * The value associated with the given attribute name.
   *
   * @param {string} name An attribute name associated with the RDN.
   *
   * @returns {*}
   */
  getValue (name) {
    return this.#attributes.get(name)?.value
  }

  /**
   * Determine if the RDN has a specific attribute assigned.
   *
   * @param {string} name The name of the attribute.
   *
   * @returns {boolean}
   */
  has (name) {
    return this.#attributes.has(name)
  }

  /**
   * All attribute names associated with the RDN.
   *
   * @returns {IterableIterator<string>}
   */
  keys () {
    return this.#attributes.keys()
  }

  /**
   * Define an attribute type and value on the RDN.
   *
   * @param {string} name
   * @param {string | import('@ldapjs/asn1').BerReader} value
   * @param {object} options Deprecated. All options will be ignored.
   *
   * @throws If any parameter is invalid.
   */
  setAttribute ({ name, value, options = {} }) {
    if (typeof name !== 'string') {
      throw Error('name must be a string')
    }

    const valType = Object.prototype.toString.call(value)
    if (typeof value !== 'string' && valType !== '[object BerReader]') {
      throw Error('value must be a string or BerReader')
    }
    if (Object.prototype.toString.call(options) !== '[object Object]') {
      throw Error('options must be an object')
    }

    const startsWithAlpha = str => /^[a-zA-Z]/.test(str) === true
    if (startsWithAlpha(name) === false && isDottedDecimal(name) === false) {
      throw Error('attribute name must start with an ASCII alpha character or be a numeric OID')
    }

    const attr = { value, name }
    for (const [key, val] of Object.entries(options)) {
      warning.emit('LDAP_DN_DEP_001')
      if (key === 'value') continue
      attr[key] = val
    }

    this.#attributes.set(name, attr)
  }

  /**
   * Convert the RDN to a string representation. If an attribute value is
   * an instance of `BerReader`, the value will be encoded appropriately.
   *
   * @example Dotted Decimal Type
   * const rdn = new RDN({
   *   cn: '#foo',
   *   '1.3.6.1.4.1.1466.0': '#04024869'
   * })
   * rnd.toString()
   * // => 'cn=\23foo+1.3.6.1.4.1.1466.0=#04024869'
   *
   * @example Unescaped Value
   * const rdn = new RDN({
   *   cn: '#foo'
   * })
   * rdn.toString({ unescaped: true })
   * // => 'cn=#foo'
   *
   * @param {object} [options]
   * @param {boolean} [options.unescaped=false] Return the unescaped version
   * of the RDN string.
   *
   * @returns {string}
   */
  toString ({ unescaped = false } = {}) {
    let result = ''
    const isHexEncodedValue = val => /^#([0-9a-fA-F]{2})+$/.test(val) === true

    for (const entry of this.#attributes.values()) {
      result += entry.name + '='

      if (isHexEncodedValue(entry.value)) {
        result += entry.value
      } else if (Object.prototype.toString.call(entry.value) === '[object BerReader]') {
        let encoded = '#'
        for (const byte of entry.value.buffer) {
          encoded += Number(byte).toString(16).padStart(2, '0')
        }
        result += encoded
      } else {
        result += unescaped === false ? escapeValue(entry.value) : entry.value
      }

      result += '+'
    }

    return result.substring(0, result.length - 1)
  }

  /**
   * @returns {string}
   *
   * @deprecated Use {@link toString}.
   */
  format () {
    // If we decide to add back support for this, we should do it as
    // `.toStringWithFormatting(options)`.
    warning.emit('LDAP_DN_DEP_002')
    return this.toString()
  }

  /**
   * @param {string} name
   * @param {string} value
   * @param {object} options
   *
   * @deprecated Use {@link setAttribute}.
   */
  set (name, value, options) {
    warning.emit('LDAP_DN_DEP_003')
    this.setAttribute({ name, value, options })
  }

  /**
   * Determine if an object is an instance of {@link RDN} or is at least
   * a RDN-like object. It is safer to perform a `toString` check.
   *
   * @example Valid Instance
   * const Rdn = new RDN()
   * RDN.isRdn(rdn) // true
   *
   * @example RDN-like Instance
   * const rdn = { name: 'cn', value: 'foo' }
   * RDN.isRdn(rdn) // true
   *
   * @example Preferred Check
   * let rdn = new RDN()
   * Object.prototype.toString.call(rdn) === '[object LdapRdn]' // true
   *
   * dn = { name: 'cn', value: 'foo' }
   * Object.prototype.toString.call(dn) === '[object LdapRdn]' // false
   *
   * @param {object} rdn
   * @returns {boolean}
   */
  static isRdn (rdn) {
    if (Object.prototype.toString.call(rdn) === '[object LdapRdn]') {
      return true
    }

    const isObject = Object.prototype.toString.call(rdn) === '[object Object]'
    if (isObject === false) {
      return false
    }

    if (typeof rdn.name === 'string' && typeof rdn.value === 'string') {
      return true
    }

    for (const value of Object.values(rdn)) {
      if (
        typeof value !== 'string' &&
        Object.prototype.toString.call(value) !== '[object BerReader]'
      ) return false
    }

    return true
  }
}

module.exports = RDN