var localStorage;
var document;
var window;
var XMLHttpRequest;
var lastCreatedXhr;

function testGetSetValue() {
  localStorage = new LocalStorageFake();
  GM_setValue('string', 'value');
  assert('value', GM_getValue('string'));
  GM_setValue('integer', 123);
  assert(123, GM_getValue('integer'));
  GM_setValue('boolean', true);
  assert(true, GM_getValue('boolean'));

  assert(undefined, GM_getValue('notset'));
  assert('default', GM_getValue('notset', 'default'));

  // illegal values
  assertThrow(function() {
    GM_setValue('illegal value', null);
  });
  assertThrow(function() {
    GM_setValue('illegal value', 1.5);
  });
}

function testDeleteValue() {
  localStorage = new LocalStorageFake();
  GM_setValue('delete', 'value');
  assert('value', GM_getValue('delete'));
  GM_deleteValue('delete');
  assert(undefined, GM_getValue('delete'));
  GM_deleteValue('notset');
}

function testListValues() {
  localStorage = new LocalStorageFake();
  var a = GM_listValues();
  assert(0, a.length);

  GM_setValue('one', 'first');
  a = GM_listValues();
  assert(1, a.length);
  assert('one', a[0]);

  GM_setValue('two', 'second');
  a = GM_listValues();

  // Test that keys that are not namespaced can't be read.
  localStorage.setItem('three', 'third');
  assert(2, a.length);
  assert(true, a.indexOf('one') >= 0);
  assert(true, a.indexOf('two') >= 0);
}

function testGetResourceURL() {
  assertThrow(function() {
    var resource = GM_getResourceURL('urlResourceName');
  });
}

function testGetResourceText() {
  assertThrow(function() {
    var resource = GM_getResourceText('textResourceName');
  });
}

function testAddStyle() {
  var documentElement = new ElementFake('');
  var head = new ElementFake('head');
  document = new DocumentFake(documentElement, head);
  var css = 'color: #decaff;';
  GM_addStyle(css);
  assert(0, documentElement.childNodes.length);
  assert(1, head.childNodes.length);
  var style = head.childNodes[0];
  assert("style", style.tagName);
  assert("text/css", style.type);
  assert(1, style.childNodes.length);
  var textNode = style.childNodes[0];
  assert(css, textNode.text);

  document = new DocumentFake(documentElement, null);
  GM_addStyle(css);
  assert(1, documentElement.childNodes.length);
  var style = documentElement.childNodes[0];
  assert("text/css", style.type);
  assert(1, style.childNodes.length);
  textNode = style.childNodes[0];
  assert(css, textNode.text);
}

function testXmlhttpRequest() {
  XMLHttpRequest = XMLHttpRequestFake;
  var url = 'http://example.com';
  
  var onLoadCallback = function(state) {
    onLoadCallbackResponseState = state;
  };
  var onErrorCallback = function(state) {
    onErrorCallbackResponseState = state;
  };
  var onReadyStateChangeCallback = function(state) {
    onReadyStateChangeCallbackResponseState = state;
  };

  var details = {
    onload: onLoadCallback,
    onerror: onErrorCallback,
    onreadystatechange: onReadyStateChangeCallback,
    method: 'GET',
    url: url,
    overrideMimeType: 'text/html',
    headers: {
      'X-Header': 'foo'
    },
    data: 'data'
  };

  GM_xmlhttpRequest(details);
  var xhr = lastCreatedXhr;

  assert('GET', xhr.openedMethod);
  assert(url, xhr.openedUrl);
  assert('text/html', xhr.overrideMimeType);
  assert('foo', xhr.requestHeaders['X-Header']);
  assert('data', xhr.sentBody);

  xhr.responseText = 'foo';
  xhr.responseHeaders['X-Response'] = 'foo';
  xhr.status = 200;
  xhr.statusText = 'OK';

  xhr.readyState = 1;
  xhr.onreadystatechange();
  var state = onReadyStateChangeCallbackResponseState;
  assert(xhr.responseText, state.responseText);
  assert(xhr.readyState, state.readyState);
  assert('', state.responseHeaders);
  assert(0, state.status);
  assert('', state.statusText);
  assert('', state.finalUrl);

  xhr.readyState = 0;
  xhr.onerror();
  state = onErrorCallbackResponseState;
  assert(xhr.responseText, state.responseText);
  assert(xhr.readyState, state.readyState);
  assert('', state.responseHeaders);
  assert(0, state.status);
  assert('', state.statusText);
  assert('', state.finalUrl);

  xhr.readyState = 4;
  xhr.onload();
  state = onLoadCallbackResponseState;
  assert(xhr.responseText, state.responseText);
  assert(xhr.readyState, state.readyState);
  assert('X-Response: foo\r\n', state.responseHeaders);
  assert(xhr.status, state.status);
  assert(xhr.statusText, state.statusText);
  assert(url, state.finalUrl);
}

function testRegisterMenuCommand() {
  assertThrow(function() {
    GM_registerMenuCommand('name', function() {}, 'a', '', 'a');
  });
}

function testOpenInTab() {
  var mockWindow = {
    open: function(url, name, opt_options) {
      this.openedUrl = url;
      this.openedName = name;
      this.openedOptions = opt_options;
    }
  };
  window = mockWindow;
  var url = 'http://example.com';
  GM_openInTab(url);
  assert(mockWindow.openedUrl, url);
}

function testLog() {
  var mockWindow = {
    console: {
      message: null,
      log: function(message) {
        this.message = message;
      }
    }
  };
  window = mockWindow;
  var message = 'hello world';
  GM_log(message);
  assert(message, mockWindow.console.message);
}

function LocalStorageFake() {
  this.map_ = {};
  this.keys_ = [];
}
LocalStorageFake.prototype = {
  length: 0,
  key: function(index) {
    if (index >= this.length) {
      throw new Error('INDEX_SIZE_ERR');
    }
    return this.keys_[index];
  },
  getItem: function(key) {
    if (key in this.map_) {
      return this.map_[key];
    }
    return null;
  },
  setItem: function(key, data) {
    this.map_[key] = data;
    this.updateKeys_();
  },
  removeItem: function(key) {
    delete this.map_[key];
    this.updateKeys_();
  },
  clear: function() {
    this.map_ = {};
    this.updateKeys_();
  },
  updateKeys_: function() {
    var keys = [];
    for (var key in this.map_) {
      keys.push(key);
    }
    this.keys_ = keys;
    this.length = keys.length;
  }
}

function DocumentFake(documentElement, head) {
  this.documentElement = documentElement;
  this.head_ = head;
}
DocumentFake.prototype = {
  getElementsByTagName: function(tagName) {
    if (tagName == 'head' && this.head_) {
      return [this.head_];
    }
    return [];
  },
  createElement: function(tagName) {
    return new ElementFake(tagName);
  },
  createTextNode: function(text) {
    return new TextNodeFake(text);
  }
}

function ElementFake(tagName) {
  this.tagName = tagName;
  this.childNodes = [];
}
ElementFake.prototype = {
  appendChild: function(e) {
    this.childNodes.push(e);
    return e;
  }
}

function TextNodeFake(text) {
  this.text = text;
}

function XMLHttpRequestFake() {
  lastCreatedXhr = this;
  this.onload = null;
  this.onerror = null;
  this.onreadystatechange = null;
  this.openedMethod = null;
  this.openededUrl = null;
  this.overriddenMimeType = null;
  this.requestHeaders = {};
  this.sentBody = null;
  this.responseText = null;
  this.readyState = null;
  this.responseHeaders = {};
  this.status = null;
  this.statusText = null;
}
XMLHttpRequestFake.prototype = {
  open: function(method, url) {
    this.openedMethod = method;
    this.openedUrl = url;
  },
  overrideMimeType: function(mimeType) {
    this.overrideMimeType = mimeType;
  },
  setRequestHeader: function(header, value) {
    this.requestHeaders[header] = value;
  },
  send: function(opt_body) {
    this.sentBody = opt_body;
  },
  getAllResponseHeaders: function() {
    var s = '';
    for (var header in this.responseHeaders) {
      // The delimiter used in Webkit's XMLHttpRequest is \r\n, however
      // the new Chrome networking code (and Firefox) uses \n, so watch
      // out for this!
      s += header + ': ' + this.responseHeaders[header] + '\r\n';
    }
    return s;
  }
}

function assert(expected, actual) {
  if (expected !== actual) {
    throw new Error('Assert failed: "' + expected + '" !== "' + actual + '"');
  }
}

function fail() {
  throw new Error('Fail');
}

function assertThrow(f) {
  var threw = false;
  try {
    f();
  } catch(e) {
    threw = true;
  }
  if (!threw) {
    throw new Error('Assert failed, expression did not throw.');
  }
}