/*eslint no-var:0, prefer-arrow-callback: 0, object-shorthand: 0 */ 'use strict';

var Punycode = require('punycode');

var internals = {};

// // Read rules from file. // internals.rules = require('./data/rules.json').map(function (rule) {

return {
  rule: rule,
  suffix: rule.replace(/^(\*\.|\!)/, ''),
  punySuffix: -1,
  wildcard: rule.charAt(0) === '*',
  exception: rule.charAt(0) === '!'
};

});

// // Check is given string ends with `suffix`. // internals.endsWith = function (str, suffix) {

return str.indexOf(suffix, str.length - suffix.length) !== -1;

};

// // Find rule for a given domain. // internals.findRule = function (domain) {

var punyDomain = Punycode.toASCII(domain);
return internals.rules.reduce(function (memo, rule) {

  if (rule.punySuffix === -1){
    rule.punySuffix = Punycode.toASCII(rule.suffix);
  }
  if (!internals.endsWith(punyDomain, '.' + rule.punySuffix) && punyDomain !== rule.punySuffix) {
    return memo;
  }
  // This has been commented out as it never seems to run. This is because
  // sub tlds always appear after their parents and we never find a shorter
  // match.
  //if (memo) {
  //  var memoSuffix = Punycode.toASCII(memo.suffix);
  //  if (memoSuffix.length >= punySuffix.length) {
  //    return memo;
  //  }
  //}
  return rule;
}, null);

};

// // Error codes and messages. // exports.errorCodes = {

DOMAIN_TOO_SHORT: 'Domain name too short.',
DOMAIN_TOO_LONG: 'Domain name too long. It should be no more than 255 chars.',
LABEL_STARTS_WITH_DASH: 'Domain name label can not start with a dash.',
LABEL_ENDS_WITH_DASH: 'Domain name label can not end with a dash.',
LABEL_TOO_LONG: 'Domain name label should be at most 63 chars long.',
LABEL_TOO_SHORT: 'Domain name label should be at least 1 character long.',
LABEL_INVALID_CHARS: 'Domain name label can only contain alphanumeric characters or dashes.'

};

// // Validate domain name and throw if not valid. // // From wikipedia: // // Hostnames are composed of series of labels concatenated with dots, as are all // domain names. Each label must be between 1 and 63 characters long, and the // entire hostname (including the delimiting dots) has a maximum of 255 chars. // // Allowed chars: // // * `a-z` // * `0-9` // * `-` but not as a starting or ending character // * `.` as a separator for the textual portions of a domain name // // * en.wikipedia.org/wiki/Domain_name // * en.wikipedia.org/wiki/Hostname // internals.validate = function (input) {

// Before we can validate we need to take care of IDNs with unicode chars.
var ascii = Punycode.toASCII(input);

if (ascii.length < 1) {
  return 'DOMAIN_TOO_SHORT';
}
if (ascii.length > 255) {
  return 'DOMAIN_TOO_LONG';
}

// Check each part's length and allowed chars.
var labels = ascii.split('.');
var label;

for (var i = 0; i < labels.length; ++i) {
  label = labels[i];
  if (!label.length) {
    return 'LABEL_TOO_SHORT';
  }
  if (label.length > 63) {
    return 'LABEL_TOO_LONG';
  }
  if (label.charAt(0) === '-') {
    return 'LABEL_STARTS_WITH_DASH';
  }
  if (label.charAt(label.length - 1) === '-') {
    return 'LABEL_ENDS_WITH_DASH';
  }
  if (!/^[a-z0-9\-]+$/.test(label)) {
    return 'LABEL_INVALID_CHARS';
  }
}

};

// // Public API //

// // Parse domain. // exports.parse = function (input) {

if (typeof input !== 'string') {
  throw new TypeError('Domain name must be a string.');
}

// Force domain to lowercase.
var domain = input.slice(0).toLowerCase();

// Handle FQDN.
// TODO: Simply remove trailing dot?
if (domain.charAt(domain.length - 1) === '.') {
  domain = domain.slice(0, domain.length - 1);
}

// Validate and sanitise input.
var error = internals.validate(domain);
if (error) {
  return {
    input: input,
    error: {
      message: exports.errorCodes[error],
      code: error
    }
  };
}

var parsed = {
  input: input,
  tld: null,
  sld: null,
  domain: null,
  subdomain: null,
  listed: false
};

var domainParts = domain.split('.');

// Non-Internet TLD
if (domainParts[domainParts.length - 1] === 'local') {
  return parsed;
}

var handlePunycode = function () {

  if (!/xn--/.test(domain)) {
    return parsed;
  }
  if (parsed.domain) {
    parsed.domain = Punycode.toASCII(parsed.domain);
  }
  if (parsed.subdomain) {
    parsed.subdomain = Punycode.toASCII(parsed.subdomain);
  }
  return parsed;
};

var rule = internals.findRule(domain);

// Unlisted tld.
if (!rule) {
  if (domainParts.length < 2) {
    return parsed;
  }
  parsed.tld = domainParts.pop();
  parsed.sld = domainParts.pop();
  parsed.domain = [parsed.sld, parsed.tld].join('.');
  if (domainParts.length) {
    parsed.subdomain = domainParts.pop();
  }
  return handlePunycode();
}

// At this point we know the public suffix is listed.
parsed.listed = true;

var tldParts = rule.suffix.split('.');
var privateParts = domainParts.slice(0, domainParts.length - tldParts.length);

if (rule.exception) {
  privateParts.push(tldParts.shift());
}

parsed.tld = tldParts.join('.');

if (!privateParts.length) {
  return handlePunycode();
}

if (rule.wildcard) {
  tldParts.unshift(privateParts.pop());
  parsed.tld = tldParts.join('.');
}

if (!privateParts.length) {
  return handlePunycode();
}

parsed.sld = privateParts.pop();
parsed.domain = [parsed.sld,  parsed.tld].join('.');

if (privateParts.length) {
  parsed.subdomain = privateParts.join('.');
}

return handlePunycode();

};

// // Get domain. // exports.get = function (domain) {

if (!domain) {
  return null;
}
return exports.parse(domain).domain || null;

};

// // Check whether domain belongs to a known public suffix. // exports.isValid = function (domain) {

var parsed = exports.parse(domain);
return Boolean(parsed.domain && parsed.listed);

};