var config = exports;
var util = require('util');
var DaimyoError = require('./error');
var samurayKeyRe = /^[0-9a-f]{24}$/;
var isConfigured = false;

config.DAIMYO_VERSION = '0.1.5';

var settings = {};
settings.merchantKey = '';
settings.apiPassword = '';
settings.processorId = '';
settings.currency = 'USD';
settings.allowedCurrencies = ['USD'];
settings.sandbox = false;
settings.enabled = true; // Does not make any actual API calls if false
settings.debug = false; // Enables *blocking* debug output to STDOUT
settings.apiVersion = 1; // Don't change this... unless you need to
settings.allowMultipleSetOption = false;

config.configure = function(opts) {
  debug('Configuring Daimyo with: \n' + util.inspect(opts));
  if (!opts.merchantKey || !opts.apiPassword || !opts.processorId) {
    throw new DaimyoError('system', 'Incomplete Samurai API credentials', opts);
  }
  Object.keys(opts).forEach(function(key) {
    config.option(key, opts[key]);
  });
  isConfigured = true;
};

config.option = function(option, value) {
  if (typeof value !== 'undefined') {
    debug('Setting Daimyo key `' + option + '` to `' + value.toString() + '`');
    
    // Do not allow an option to be set twice unless it's `currency`
    if (isConfigured && 
        !settings.allowMultipleSetOption && 
        option !== 'currency') {
      throw new DaimyoError(
        'system', 
        'Option ' + option + ' is already locked', 
        option);
    }

    switch (option) {
    case 'merchantKey':
    case 'apiPassword':
    case 'processorId':
      // Throw if doesn't look like valid key
      if (!samurayKeyRe.exec(value)) {
        throw new DaimyoError('system', 'Invalid setting', option);
      }
      settings[option] = value;
      break;
    case 'currency':
      settings[option] = value;
      break;
    case 'sandbox':
    case 'enabled':
    case 'debug':
    case 'allowMultipleSetOption':
      settings[option] = Boolean(value);
      break;
    case 'allowedCurrencies':
      if (!Array.isArray(value)) {
        throw new DaimyoError('system', 'Allowed currencies must be an array', null);
      }
      if (value.indexOf(settings.currency) < 0) {
        value.push(settings.currency);
      }
      settings.allowedCurrencies = value;
      break;
    default:
      // Do not allow unknown options to be set
      throw new DaimyoError('system', 'Unrecognized configuration option', option);
    }
  }
  return settings[option];
};

var config = require('./config');
var debug = config.debug;
var check = require('./check');
var DaimyoError = require('./error');
var authpost = require('./authpost');
var xmlutils = require('./xmlutils');
var messages = require('./messages');
var tokenRe = /^[0-9a-f]{24}$/;
var daimyo = exports;

function Card(opts) {
  var self = this;

  // Add accessors in a close to prevent tampering
  (function(self) {
    // This property contains the original/initial values of all fields
    // Do not motify this object directly. Use _dirty setter.
    var originalValues = {
      number: undefined,
      csc: undefined,
      year: undefined,
      month: undefined,
      firstName: '',
      lastName: '',
      address1: '',
      address2: '',
      city: '',
      state: '',
      zip: '',
      custom: undefined
    };

    // Update _originalValues keys if matching keys are found in object argument
    self.__defineSetter__('_dirty', function(object) {
      Object.keys(originalValues).forEach(function(field) {
        if (object[field]) { originalValues[field] = object[field]; }
      });
    });

    // Check fields for dirtiness and return the names of dirty fields as Array
    self.__defineGetter__('_dirty', function() {
      var dirtyFields = [];
     
      // Check all fields in _originalValues and determine the dirty fields
      Object.keys(originalValues).forEach(function(field) {
        if (self[field] !== originalValues[field]) { 
          dirtyFields.push(field); 
        }
      });

      return dirtyFields;
    });

    // Resets dirty fields
    self._resetDirty = function() {
      var self = this;
      self._dirty = {
        number: self.number,
        csc: self.csc,
        year: self.year,
        month: self.month,
        firstName: self.firstName,
        lastName: self.lastName,
        address1: self.address1,
        address2: self.address2,
        city: self.city,
        state: self.state,
        zip: self.zip
      };
    };

  }(self));

  // Setters and getters for `year`, `month`, and `number` properties
  (function(self, check) {
    
    // Original values
    var yearVal;
    var monthVal;
    var numberVal;
    var custVal;

    // Helper for year normalization
    function normalizeYear(order, year) {
      return (Math.floor(new Date().getFullYear() / order) * order) + year;
    }

    self.__defineSetter__('year', function(year) {
      if (!year) { return; }

      year = parseInt(year, 10);
      if (year < 10) {
        yearVal = normalizeYear(10, year);
      } else if (year >= 10 && year < 100) {
        yearVal = normalizeYear(100, year);
      } else {
        yearVal = year;
      }
    });

    self.__defineGetter__('year', function() {
      return yearVal;
    });

    self.__defineSetter__('month', function(month) {
      month = parseInt(month, 10);
      if (isNaN(month) || month < 1 || month > 12) {
        monthVal = null;
      } else {
        monthVal = month;
      }
    });

    self.__defineGetter__('month', function() {
      return monthVal;
    });

    self.__defineSetter__('number', function(value) {
      numberVal = check.extractDigits(value);
      self.issuer = check.getIssuer(value);
    });

    self.__defineGetter__('number', function() {
      return numberVal;
    });

    self.__defineSetter__('custom', function(value) {
      if (!value) {
        return;
      }
      try {
        custVal = JSON.stringify(value);
      } catch(e) {

}
    });

    self.__defineGetter__('custom', function() {
      try {
        return JSON.parse(custVal);
      } catch(e) {

}
    });

    self.__defineGetter__('customJSON', function() {
      return custVal;
    });

  }(self, check));

  // Process the options
  if (opts) {
    if (typeof opts.token !== 'undefined') {
      if (!tokenRe.test(opts.token)) {
        throw new DaimyoError('system', 'Invalid token', null);
      } 

      debug('Using payment token instead of credit card details.');
      self.token = opts.token;

    } else {
      debug('No valid token found. Using credit card details.');
      self.number = opts.number;
      self.csc = opts.csc;

      // Card number and CSC are required
      if (!self.number) {
        throw new DaimyoError('system', 'Card number is required', null);
      }
      if (!self.csc) {
        throw new DaimyoError('system', 'CSC is required', null);
      }

      self.year = opts.year;
      self.month = parseInt(opts.month, 10);
      self.firstName = opts.firstName || '';
      self.lastName = opts.lastName || '';
      self.address1 = opts.address1 || '';
      self.address2 = opts.address2 || '';
      self.city = opts.city || '';
      self.state = opts.state || '';
      self.zip = opts.zip || '';
      self.custom = opts.custom;

      // Set card issuer
      self.issuer = check.getIssuer(self.number) || '';
    }
  }
}

Card.prototype.isValid = function() {
  if (!check.mod10check(this.number)) {
    return false;
  }

  if (!check.cscCheck(this.number, this.csc)) {
    return false;
  }

  return true;
};

Card.prototype.isExpired = function() {
  var expYear = new Date().getFullYear();
  var expMonth = new Date().getMonth() + 1; // 0-indexed

  if (!this.year || !this.month) { return true; }

  // Expired card should not be last month this year or older
  if (this.year < expYear) { return true; }
  if (this.year === expYear && this.month < expMonth) { return true; }

  return false;
};

Card.prototype.create = function(callback) {
  var querystring = require('querystring');
  var self = this;
  var paymentTokenRe = /payment_method_token=([0-9a-f]{24})/;

  if (this.token) {
    callback(null, this.token);
    return;
  }

  paymentData = {
    'redirect_url': 'http://example.com', // Bogus URL, required by API
    'merchant_key': config.option('merchantKey'),
    'custom': this.customJSON || '',
    'credit_card[first_name]': this.firstName || '',
    'credit_card[last_name]': this.lastName || '',
    'credit_card[address_1]': this.address1 || '',
    'credit_card[address_2]': this.address2 || '',
    'credit_card[city]': this.city || '',
    'credit_card[state]': this.state || '',
    'credit_card[zip]': this.zip || '',
    'credit_card[card_type]':  this.issuer || '',
    'credit_card[card_number]': this.number || '',
    'credit_card[cvv]': this.csc || '',
    'credit_card[expiry_month]': this.month || '',
    'credit_card[expiry_year]': this.year || ''
  };

  // Add sandbox parameter if the sandbox config option is enabled
  if (config.option('sandbox')) {
    paymentData.sandbox = true;
  }

  // Reformat our data as required by the API
  paymentData = querystring.stringify(paymentData);

  authpost.makeRequest({
    method: 'POST',
    payload: paymentData
  }, function(err, res) {
    var errMsg;

    if (err && err instanceof DaimyoError) {
      callback(err);
    }
    if (err) {
      callback(new DaimyoError('system', 'Error making create payment method request', err));
      return;
    }
    if (res.status !== 302) {
      // Parse the body to find the error
      callback(new DaimyoError(
        'system', 
        'Gateway responded with non-302 status', 
        {
          status: res.status, 
          messages: messages.translateAll(xmlutils.extractMessages(res.body))
        }
      ));
      return;
    }
    if (!res.headers.location) {
      callback(new DaimyoError('system', 'Gateway failed to send the location header', res.headers));
      return;
    }

    // Parse the location header to extract the token
    self.token = paymentTokenRe.exec(res.headers.location)[1];
    self._resetDirty();
    callback(null);
  });
 
};

}
  }

  self._resetDirty();

  return true;
};

Card.prototype.load = function(callback) {
  var self = this;

  self._rejectNoToken(callback);

  self._executeRequest({
    path: self._getTokenPath()
  }, callback);

};

Card.prototype.update = function(callback) {
  var updatedFields = {};
  var payload = '';
  var self = this;

  self._rejectNoToken(callback);

  // If nothing was updated, just call the callback and pretend it was updated
  if (!self._dirty.length) {
    callback(null);
    return;
  }

  // Get all dirty fields
  self._dirty.forEach(function(field) {
    updatedFields[field] = self[field];
  });

  // We have to rename a few fields
  updatedFields = xmlutils.toSamurai(updatedFields, daimyo.MAPPINGS);

  // Construct the XML payload
  payload = xmlutils.toXML(updatedFields, 'payment_method');

  self._executeRequest({
    path: self._getTokenPath(),
    method: 'PUT',
    payload: payload
  }, callback);

};

Card.prototype.retain = function(callback) {
  var self = this;

  self._rejectNoToken(callback);

  self._executeRequest({
    path: self._getTokenPath('/retain'),
    method: 'POST'
  }, callback);

};

Card.prototype.redact = function(callback) {
  var self = this;

  self._rejectNoToken(callback);

  self._executeRequest({
    path: self._getTokenPath('/redact'),
    method: 'POST'
  }, callback);

};

daimyo.Card = Card;

var config = require('./config');
var DaimyoError = require('./error');
var xmlutils = require('./xmlutils');
var authpost = require('./authpost');
var messages = require('./messages');
var ducttape = require('./ducttape');
var daimyoRecipes = require('./daimyo').recipes;
var debug = config.debug;
var transaction = exports;

var VALID_TRANSACTIONS = ['purchase', 'authorize', 'capture', 'void', 'credit'];

transaction.MAPPINGS = {
  currency: 'currency_code'
};

function getTransactionPath(type, transactionId) {
  var subpath = '/processors/';
  if (transactionId) {
    subpath = '/transactions/';
  }
  return subpath + (transactionId || config.option('processorId')) + '/' + 
    type + '.xml';
}

transaction.Transaction = function(opts) {
  // opts are required
  if (!opts) {
    throw new DaimyoError('system', 'Missing options object', null);
  }
  // opts.type are required
  if (!opts.type || VALID_TRANSACTIONS.indexOf(opts.type) < 0) {
    throw new DaimyoError('system', 'Missing or invalid transaction type', null);
  }
  // opts.data are required
  if (!opts.data) {
    throw new DaimyoError('system', 'Missing payload data');
  }

  // Make data and path tamper-free properties
  ducttape.addOneTimeAccessor(this, 'data');
  ducttape.addOneTimeAccessor(this, 'type');
  ducttape.addOneTimeAccessor(this, 'path');
  ducttape.addOneTimeAccessor(this, 'useToken');

  this.type = opts.type;

  this.useToken = ['credit', 'void'].indexOf(this.type) === -1;
    
  // Some defaults for complex transactions
  if (!opts.transactionId) {
    opts.data.type = opts.type;
    opts.data.currency = opts.data.currency || config.option('currency');
  }

  this.data = opts.data;
  this.path = getTransactionPath(opts.type, opts.transactionId);

  // Add methods to remember and check the response validation hash
  (function(self, ducttape) {
    var hash;

    // Remember the hash (works only the first time)
    self.rememberHash = function(val) {
      if (!hash) {
        hash = val;
      }
    };

    // Compare given value to the remembered hash
    self.checkHash = function(val) {

      // Always fail if no hash is remembered
      if (!hash) { return false; }

      return val === hash;
    };

  }(this, ducttape));

};

}
  }

  self.receipt.referenceId = transData.reference_id;
  self.receipt.transactionId = transData.transaction_token;
  self.receipt.createdAt = transData.created_at;
  self.receipt.descriptor = transData.descriptor;
  self.receipt.type = transData.transaction_type.toLowerCase();
  self.receipt.amount = transData.amount;
  self.receipt.currency = transData.currency_code;
  self.receipt.customerReference = transData.customer_reference;
  self.receipt.billingReference = transData.billing_reference;
  self.receipt.success = transData.success;

  // Update the card object from payment method response information
  if (self.useToken) {
    card.method = {};
    card.method.valid = methodData.is_sensitive_data_valid;
    card.method.updatedAt = methodData.updated_at;
    card.method.createdAt = methodData.created_at;
    card.method.retained = methodData.is_retained;
    card.method.redacted = methodData.is_redacted;
    card.last4 = methodData.last_four_digits;
    card.issuer = methodData.card_type;
    card.year = methodData.expiry_year;
    card.month = methodData.expiry_month;
    card.firstName = methodData.first_name;
    card.lastName = methodData.last_name;
    card.address1 = methodData.address_1;
    card.address2 = methodData.address_2;
    card.city = methodData.city;
    card.state = methodData.state;
    card.zip = methodData.zip;
    card.country = methodData.country;
  }

  // Parse card's custom data
  if (methodData.custom) {
    try {
      card.custom = JSON.parse(methodData.custom);
    } catch (err2) {

}
  }

  return true;
};

transaction.Transaction.prototype.process = function(card, callback) {
  var self = this;
  var transactionData;
  
  if (typeof card === 'function') {
    callback = card;
    card = null;
  }

  if (self.useToken && (!card || !card.token)) {
    callback(new DaimyoError('system', 'Card has no token', null));
    return;
  }

  // Augment transaction data with token
  transactionData = self.data;

  // Currency check
  if (transactionData.currency &&
      config.option('allowedCurrencies').indexOf(transactionData.currency) < 0) {
    
    callback(new DaimyoError(
      'system', 
      'Currency not allowed', 
      transactionData.currency
    ));
    return;

  }


  if (!transactionData.custom) {
    transactionData.custom = {};
  }

  // Add response validation hash and remember it
  transactionData.custom._check = ducttape.randomHash();
  self.rememberHash(transactionData.custom._check);

  // JSONify custom field
  try {
    transactionData.custom = JSON.stringify(transactionData.custom);
  } catch(e) {
    // If JSONification failes, remove the custom data completely
    delete transactionData.custom;
  }

  if (self.useToken) {
    transactionData.paymentMethodToken = card.token;
  }

  transactionData = xmlutils.toSamurai(transactionData, transaction.MAPPINGS);

  authpost.makeRequest({
    path: self.path,
    payload: xmlutils.toXML(transactionData, 'transaction'),
    method: 'POST'
  }, function(err, res) {
    // Error handling

    if (err && err.category === 'system') {
      callback(err);
      return;
    }

    if (res.status !== 200) {
      callback(new DaimyoError(
        'system',
        'Gateway responded with non-200 status',
        {status: res.status, body: res.body, 
         messages: err && messages.translateAll(err.details)}
      ));
      return;
    }

    // This should always be true unless there were system errors
    if (err && err.category == 'gateway') {
      self.messages = messages.translateAll(err.details, 'en_US');
    }

    // Load transaction data and payment method data
    if (!self._loadFromResponse(res.body, card)) {
      callback(new DaimyoError(
        'transaction',
        'Request data does not match the response data',
        null
      ));
    }

    // Exit with no error
    callback(null);
  });

};

(function($, JSON, window) {

  var originalDomain = window.document.domain;
  var samuraiURI = 'https://api.samurai.feefighters.com/v1/payment_methods';
  var timeoutLabel;
  var timedOut = false;
  var dataReceived = false;
  var timeoutInterval = 40000; // 40 seconds

function removeForm() {
    $('#samurai-form').remove();
    removeIframe();
  }

$.ashigaru = function(data, merchantKey, redirectURI, callback) {
    var form;

    if (!data || !merchantKey || !redirectURI || !callback) {
      throw ('All arguments are required');
    }

    var fullData = {
      firstName: '',
      lastName: '',
      address1: '',
      address2: '',
      city: '',
      state: '',
      zip: '',
      number: '',
      csc: '',
      year: '',
      month: '',
      custom: {}
    };

    $.extend(fullData, data);

    // Serialize custom data and ignore it on failure
    try {
      // JSON-ify data
      fullData.custom = JSON.stringify(fullData.custom);
      // Escape single quotes
      fullData.custom = fullData.custom.replace("'", "\\'");
    } catch(e) {

}

    var formHTML = '<form id="samurai-form" style="display:none" ' +
      'action="$requestURI" method="POST" target="samurai-iframe">' + 
      '<input type="hidden" name="merchant_key" value="$merchantkey">'+
      '<input type="hidden" name="redirect_url" value="$redirecturl">' +
      '<input type="hidden" name="custom" value=\'$custom\'>' +
      (data.sandbox &amp;&amp; '<input type="hidden" name="sandbox" value="true">' || '') +
      '<input type="hidden" name="credit_card[first_name]" value="$firstName">'+
      '<input type="hidden" name="credit_card[last_name]" value="$lastName">' +
      '<input type="hidden" name="credit_card[address_1]" value="$address1">' +
      '<input type="hidden" name="credit_card[address_2]" value="$address2">' +
      '<input type="hidden" name="credit_card[city]" value="$city">' +
      '<input type="hidden" name="credit_card[state]" value="$state">' +
      '<input type="hidden" name="credit_card[zip]" value="$zip">' +
      '<input type="hidden" name="credit_card[card_number]" value="$number">' +
      '<input type="hidden" name="credit_card[card_type]" value="$issuer">' +
      '<input type="hidden" name="credit_card[cvv]" value="$csc">' +
      '<input type="hidden" name="credit_card[expiry_year]" value="$year">' +
      '<input type="hidden" name="credit_card[expiry_month]" value="$month">' +
      '</form>';

    // Replace non-data field placeholders and form attribute placeholders
    formHTML = formHTML.replace('$requestURI', samuraiURI);
    formHTML = formHTML.replace('$merchantkey', merchantKey);
    formHTML = formHTML.replace('$redirecturl', redirectURI);

    // Replace placeholders in form HTML with real data
    for (var key in fullData) {
      if (fullData.hasOwnProperty(key)) {
        formHTML = formHTML.replace('$' + key, fullData[key] || '');
      }
    }

    // Inject this into DOM
    form = $(formHTML);

    // Sanity check
    if (form.attr('action') === '$requestURI') { 
      throw 'Form error'; 
    }

    // Attach the form to body
    form.appendTo('body');

    // Submit the form
    form.unbind('submit');
    form.submit(function(e) {
      e.stopPropagation();
      return createIframe(callback);
    });

    // Fire the timout clock at 3 seconds
    timeoutLabel = window.setTimeout(function() {

      // Set the timeout flag
      timedOut = true;

      // Execute callback with error message
      if (!dataReceived) {
        callback('Connection timed out');
      }

    }, timeoutInterval);

    form.submit();
  };
 
}(jQuery, JSON, this));

var check = exports;
var NON_DIGIT_CHARS = /[^\d]+/g;

check.issuers = {
  VISA: ['Visa', /^4(\d{12}|\d{15})$/, /^\d{3}$/],
  MAST: ['MasterCard', /^5[1-5]\d{14}$/, /^\d{3}$/],
  AMEX: ['American Express', /^3[47]\d{13}$/, /^\d{4}$/],
  DINA: ['Diners Club', /^3(00|05|6\d|8\d)\d{11}$/, /^\d{3}$/],
  DISC: ['Discover', /^(622[1-9]|6011|64[4-9]\d|65\d{2})\d{12}$/, /^\d{3}$/], 
  JCB: ['JCB', /^35(28|29|[3-8]\d)\d{12}$/, /^\d{3}$/], 
  CHIN: ['China UnionPay', /^62\d{14}/, /^\d{3}$/]
};

check.extractDigits = function(s) {
  if (typeof s !== 'string') {
    return '';
  }
  return s.replace(NON_DIGIT_CHARS, '');
};

check.getIssuer = function(card, full) {
  var lastMatch = full ? ['Unknown', /^\d{16}$/, /^\d{3}$/] : 'Unknown';
  card = check.extractDigits(card);
  if (!card) {
    return 'Unknown';
  }
  Object.keys(check.issuers).forEach(function(issuer) {
    if (check.issuers[issuer][1].test(card)) {
      lastMatch = full ? check.issuers[issuer] : check.issuers[issuer][0];
    }
  });
  return lastMatch;
};

check.mod10check = function(card) {
    var sum = 0;
    var totalDigits;
    var oddEven;
    var digits;
    var i;
    var current;

    card = check.extractDigits(card);  

    if (!card) {
      // Card number contains no digits
      return null;
    }

    totalDigits = card.length;
    oddEven = totalDigits & 1;
    digits = card.split(''); // Convert to array

    for (i = totalDigits; i; --i) {
      current = totalDigits - i; 
      digit = parseInt(digits[current], 10);

      if (!((current & 1) ^ oddEven)) {
        digit = digit * 2;
      }
      if (digit > 9) {
        digit -= 9;
      }

      sum = sum + digit;
    }

    return (sum % 10) === 0 && card;
};

check.cscCheck = function(card, csc) {
  var issuerDetails;

  csc = check.extractDigits(csc);
  if (!csc) { return false; }

  issuerDetails = check.getIssuer(card, true);
  return issuerDetails[2].test(csc);
};

var xmlutils = exports;

xmlutils.toInt = function(s) {
  return parseInt(s, 10);
};

xmlutils.toFloat = function(s) {
  return parseFloat(s);
};

xmlutils.toDate = function(s) {
  return new Date(s);
};

xmlutils.toBool = function(s) {
  return s === 'true' ? true : false;
};

xmlutils.toString = function(s) {
  return s;
};

xmlutils.extractData = function(xml, recipe) {
  var result = {};

  // Should we only parse a single node?
  if (recipe['@']) {
    xml = getInnerXML(xml, recipe['@']);
  }

  Object.keys(recipe).forEach(function(key) {
    if (key === '@') {
      // Ignore this key
      return;
    }

    // Get the Regex for the recipe
    var rxp = getTagRe(key);
    var matches = matchAll(xml, rxp);

    matches.forEach(function(match) {
      if (!result.hasOwnProperty(key)) {
        result[key] = recipe[key](match.content);
      }
    });

    // If there's only one match, then return the single match w/o array
    if (result[key] && result[key].length < 2) {
      result[key] = result[key][0];
    }

  });

  return result;
};

xmlutils.hasMessages = function(xml) {
  return Boolean((/<messages[^>]*>/).exec(xml));
};

xmlutils.extractMessages = function(xml) {
  var matches = matchAll(xml, getTagRe('message'));
  var messages = [];

  matches.forEach(function(match) {
    var message = {};

    message.cls = match.attributes.subclass;
    message.context = match.attributes.context;
    message.key = match.attributes.key;
    message.text = match.content;

    messages.push(message);
  });

  return messages;
};

xmlutils.decamelize = function(s) {
  s = s.replace(/^[A-Z]/, function(match) {
    return match.toLowerCase();
  });
  s = s.replace(/[A-Z]/g, function(match) {
    return '_' + match.toLowerCase();
  });
  return s;
};

xmlutils.toXML = function(o, topLevel, keys) {
  var xml = '';

  // Was topLevel arg skipped?
  if (typeof topLevel != 'string') {
    keys = topLevel;
    topLevel = null;
  } else {
    xml += '<' + xmlutils.decamelize(topLevel) + '>\n';
  }

  keys = keys || Object.keys(o);

  keys.forEach(function(key) {
    var tagName = xmlutils.decamelize(key);
    xml += '<' + tagName + '>' + o[key].toString() + '</' + tagName + '>\n';
  });

  if (topLevel) {
    xml += '</' + xmlutils.decamelize(topLevel) + '>\n';
  }
  
  return xml;
};

xmlutils.toSamurai = function(o, mappings) {
  var remapped = {};

  Object.keys(o).forEach(function(key) {
    if (mappings.hasOwnProperty(key)) {
      remapped[mappings[key]] = o[key];
    } else {
      remapped[key] = o[key];
    }
  });

  return remapped;
};

var http = require('http');
var config = require('./config');
var debug = config.debug;
var xmlutils = require('./xmlutils');
var DaimyoError = require('./error');
var API_VER = config.option('apiVersion');
var API_HOST = 'api.samurai.feefighters.com';
var API_URL = '/v' + API_VER;
var DEFAULT_PATH = '/payment_methods';
var DAIMYO_VERSION = require('./config').DAIMYO_VERSION;

exports.makeRequest = function(opts, callback) {
  var https = require('https');
  var path;
  var method;
  var payload;
  var headers;
  var requestOptions;
  var request;

  if (!config.option('merchantKey') || !config.option('apiPassword')) {
    callback(new DaimyoError('system', 'Daimyo is not configured', null));
  }

  if (!callback && typeof opts === 'function') {
    callback = opts;
    opts = {};
  }

  // Is callback found?
  if (typeof callback !== 'function') {
    throw new Error('Callback function is required');
  }

  path = API_URL + (opts.path || DEFAULT_PATH);
  method = opts.method || 'GET'; // defaults to GET
  payload = opts.payload;

  debug(method + ' ' + path + ' ' + (payload ? 'with' : 'without') + ' payload');
  debug(payload);

  // Set headers
  headers = {
    'Authorization': generateCreds(),
    'User-Agent': 'Daimyo/' + DAIMYO_VERSION + ' Node.js/' + process.version,
    'Accepts': 'text/plain; q=0.5, text/xml; q=0.8, text/html',
    'Date': new Date().toString(),
    'Content-Length': 0
  };

  if (payload) {
    headers['Content-Length'] = payload.length;

    if (payload[0] === '<') {
      headers['Content-Type'] = 'text/xml';
    } else {
      headers['Content-Type'] = 'application/x-www-form-urlencoded';
    }
  }

  // Set request options
  requestOptions = {
    host: API_HOST,
    path: path,
    method: method,
    headers: headers
  };

  // Initialize the request object
  request = https.request(requestOptions, function(response) {
    var res = {};
  
    res.base = response;
    res.status = response.statusCode;
    res.headers = response.headers;
    res.body = '';

    // response.setEncoding('UTF-8');

    // Buffer the response body
    response.on('data', function(chunk) {
      res.body += chunk;
    });

    response.on('end', function(err) {
      var error;

      // System error
      if (err) {
        error = new DaimyoError('system', 'There was an error with the request', err);
      } else {
        error = parseMessages(res.body);
      }
      
      debug('Finished request to ' + path + ' with body: ' + res.body);
      callback(error, res);
    });
  });

  request.on('error', function(err) {
    callback(new DaimyoError('system', 'There was an error with the request', err));
  });

  if (payload) { request.write(payload); }
  request.end();
};

var ducttape = exports;

ducttape.copyArray = function copyArray(arr) {
  var clone = [];

  // Iterate `arr` and clone members to `clone`
  arr.forEach(function(item) {
    if (typeof item !== 'object') {
      // First take care of simple types
      clone.push(item);
    } else if (Array.isArray(item)) {
      // Take care of arrays
      clone.push(copyArray(item)); // recurse
    } else {
      // Take care of normal objects
      clone.push(ducttape.deepCopy(item));
    }
  });

  return clone;
};

ducttape.deepCopy = function deepCopy(obj) {
  var clone = {};

  // Iterate `obj`'s keys and clone them to `clone`
  Object.keys(obj).forEach(function(key) {
    
    // Take care of simple types
    if (typeof obj[key] !== 'object') {
      clone[key] = obj[key];
    } else if (Array.isArray(obj[key])) {
      clone[key] = ducttape.copyArray(obj[key]);
    } else {
      clone[key] = deepCopy(obj[key]);
    }
  });

  return clone;
};

ducttape.addOneTimeAccessor = function(obj, property, validator, failSilently) {
  // Protect the original value within the closure
  var val;
  var set = false;

  obj.__defineSetter__(property, function(value) {
    console.log(set);

    // Already set
    if (set) {
      return;
    }

    // Illegal value
    if (typeof validatro === 'function' && !validator(value)) {
      if (failSilently === true) {
        return;
      }
      throw new Error('Illegal value for property ' + property);
    }

  // Set the value and seal it
  val = value;
  set = true;
  });

  obj.__defineGetter__(property, function() {
    if (typeof val !== 'object') {
      return val;
    } else if (Array.isArray(val)) {
      return ducttape.copyArray(val);
    } else {
      return ducttape.deepCopy(val);
    }
  });
};

ducttape.randomString = function(len, pool) {
  var random = require('mersenne');
  var poolLength;
  var output = [];

  pool = pool || 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345' +
    '67890!@#$%^&*()_+{}][;"\'/?.,<>';
  poolLength = pool.length;

  for (var i = poolLength; i; --i) {
    output.push(pool[random.rand(poolLength)]);
  }

  return output.join('');
};

ducttape.randomHash = function() {
  var crypto = require('crypto');
  var hash = crypto.createHash('sha1');
  var rstr = ducttape.randomString(100);

  hash.update(rstr);

  return hash.digest('hex');
};

var msg = exports;

msg.translate = function(message, lang) {
  try {
    var mapping = msg.mappings[message.cls][message.context][message.key];
    lang = lang || 'en_US';
    return {
      field: mapping[0],
      message: mapping[1](lang)
    };
  } catch(e) {
    // We have an unknown message
    return {
      field: 'unknown',
      message: message.cls + ':' + message.context + ':' + message.key
    };
  }
};

msg.translateAll = function(messages, lang) {
  var errors = messages.filter(function(item) {
    return item.cls === 'error';
  });
  var info = messages.filter(function(item) {
    return item.cls === 'info';
  });
  function build(msgs) {
    var translations = {};
    msgs.forEach(function(message) {
      translation = msg.translate(message, lang);
      if (translations.hasOwnProperty(translation.field) && 
          translations[translation.field].indexOf(translation.message) < 0) {
        translations[translation.field].push(translation.message);
      } else {
        translations[translation.field] = [translation.message];
      }
    });
    return translations;
  }
  return {
    errors: build(errors),
    info: build(info)
  };
};

var util = require('util');

function DaimyoError(category, message, details) {
  Error.call(this);
  Error.captureStackTrace(this, this.constructor);
  this.category = category;
  this.message = message;
  this.details = details;
  this.name = this.constructor.name;
}

util.inherits(DaimyoError, Error);

DaimyoError.prototype.toString = function() {
  return this.category + ': ' + this.message + ': ' +
    util.inspect(this.details);
};

module.exports = DaimyoError;