/* global context testDone:true */

var requestURL =
  "//mochi.test:8888/tests/dom/cache/test/mochitest/vary.sjs?" + context;
var name = "match-vary" + context;

function checkResponse(r, response, responseText) {
  ok(r !== response, "The objects should not be the same");
  is(
    r.url,
    response.url.replace("#fragment", ""),
    "The URLs should be the same"
  );
  is(r.status, response.status, "The status codes should be the same");
  is(r.type, response.type, "The response types should be the same");
  is(r.ok, response.ok, "Both responses should have succeeded");
  is(
    r.statusText,
    response.statusText,
    "Both responses should have the same status text"
  );
  is(
    r.headers.get("Vary"),
    response.headers.get("Vary"),
    "Both responses should have the same Vary header"
  );
  return r.text().then(function (text) {
    is(text, responseText, "The response body should be correct");
  });
}

// Returns a Promise that will be resolved to an object with the following
// properties:
// * cache: A Cache object that contains one entry fetched with headers.
// * response: A Response object which is the result of fetching a request
//             with the specified headers.
// * responseText: The body of the above response object.
function setupTest(headers) {
  return setupTestMultipleEntries([headers]).then(function (test) {
    return {
      response: test.response[0],
      responseText: test.responseText[0],
      cache: test.cache,
    };
  });
}
function setupTestMultipleEntries(headers) {
  ok(Array.isArray(headers), "headers should be an array");
  return new Promise(function (resolve, reject) {
    var response, responseText, cache;
    Promise.all(
      headers.map(function (h) {
        return fetch(requestURL, { headers: h });
      })
    )
      .then(function (res) {
        response = res;
        return Promise.all(
          response.map(function (r) {
            return r.text();
          })
        );
      })
      .then(function (text) {
        responseText = text;
        return caches.open(name);
      })
      .then(function (c) {
        cache = c;
        return Promise.all(
          headers.map(function (h) {
            return c.add(new Request(requestURL, { headers: h }));
          })
        );
      })
      .then(function () {
        resolve({ response, responseText, cache });
      })
      .catch(function (err) {
        reject(err);
      });
  });
}

function testBasics() {
  var test;
  return setupTest({ WhatToVary: "Custom" })
    .then(function (t) {
      test = t;
      // Ensure that searching without specifying a Custom header succeeds.
      return test.cache.match(requestURL);
    })
    .then(function (r) {
      return checkResponse(r, test.response, test.responseText);
    })
    .then(function () {
      // Ensure that searching with a non-matching value for the Custom header fails.
      return test.cache.match(
        new Request(requestURL, { headers: { Custom: "foo=bar" } })
      );
    })
    .then(function (r) {
      is(
        typeof r,
        "undefined",
        "Searching for a request with an unknown Vary header should not succeed"
      );
      // Ensure that searching with a non-matching value for the Custom header but with ignoreVary set succeeds.
      return test.cache.match(
        new Request(requestURL, { headers: { Custom: "foo=bar" } }),
        { ignoreVary: true }
      );
    })
    .then(function (r) {
      return checkResponse(r, test.response, test.responseText);
    });
}

function testBasicKeys() {
  function checkRequest(reqs) {
    is(reqs.length, 1, "One request expected");
    ok(reqs[0].url.includes(requestURL), "The correct request expected");
    ok(
      reqs[0].headers.get("WhatToVary"),
      "Custom",
      "The correct request headers expected"
    );
  }
  var test;
  return setupTest({ WhatToVary: "Custom" })
    .then(function (t) {
      test = t;
      // Ensure that searching without specifying a Custom header succeeds.
      return test.cache.keys(requestURL);
    })
    .then(function (r) {
      return checkRequest(r);
    })
    .then(function () {
      // Ensure that searching with a non-matching value for the Custom header fails.
      return test.cache.keys(
        new Request(requestURL, { headers: { Custom: "foo=bar" } })
      );
    })
    .then(function (r) {
      is(
        r.length,
        0,
        "Searching for a request with an unknown Vary header should not succeed"
      );
      // Ensure that searching with a non-matching value for the Custom header but with ignoreVary set succeeds.
      return test.cache.keys(
        new Request(requestURL, { headers: { Custom: "foo=bar" } }),
        { ignoreVary: true }
      );
    })
    .then(function (r) {
      return checkRequest(r);
    });
}

function testStar() {
  function ensurePromiseRejected(promise) {
    return promise.then(
      function () {
        ok(false, "Promise should be rejected");
      },
      function (err) {
        is(
          err.name,
          "TypeError",
          "Attempting to store a Response with a Vary:* header must fail"
        );
      }
    );
  }
  return new Promise(function (resolve, reject) {
    var cache;
    caches.open(name).then(function (c) {
      cache = c;
      Promise.all([
        ensurePromiseRejected(
          cache.add(
            new Request(requestURL + "1", { headers: { WhatToVary: "*" } })
          )
        ),
        ensurePromiseRejected(
          cache.addAll([
            new Request(requestURL + "2", { headers: { WhatToVary: "*" } }),
            requestURL + "3",
          ])
        ),
        ensurePromiseRejected(
          fetch(
            new Request(requestURL + "4", { headers: { WhatToVary: "*" } })
          ).then(function (response) {
            return cache.put(requestURL + "4", response);
          })
        ),
        ensurePromiseRejected(
          cache.add(
            new Request(requestURL + "5", {
              headers: { WhatToVary: "*,User-Agent" },
            })
          )
        ),
        ensurePromiseRejected(
          cache.addAll([
            new Request(requestURL + "6", {
              headers: { WhatToVary: "*,User-Agent" },
            }),
            requestURL + "7",
          ])
        ),
        ensurePromiseRejected(
          fetch(
            new Request(requestURL + "8", {
              headers: { WhatToVary: "*,User-Agent" },
            })
          ).then(function (response) {
            return cache.put(requestURL + "8", response);
          })
        ),
        ensurePromiseRejected(
          cache.add(
            new Request(requestURL + "9", {
              headers: { WhatToVary: "User-Agent,*" },
            })
          )
        ),
        ensurePromiseRejected(
          cache.addAll([
            new Request(requestURL + "10", {
              headers: { WhatToVary: "User-Agent,*" },
            }),
            requestURL + "10",
          ])
        ),
        ensurePromiseRejected(
          fetch(
            new Request(requestURL + "11", {
              headers: { WhatToVary: "User-Agent,*" },
            })
          ).then(function (response) {
            return cache.put(requestURL + "11", response);
          })
        ),
      ]).then(reject, resolve);
    });
  });
}

function testMatch() {
  var test;
  return setupTest({ WhatToVary: "Custom", Custom: "foo=bar" })
    .then(function (t) {
      test = t;
      // Ensure that searching with a different Custom header fails.
      return test.cache.match(
        new Request(requestURL, { headers: { Custom: "bar=baz" } })
      );
    })
    .then(function (r) {
      is(
        typeof r,
        "undefined",
        "Searching for a request with a non-matching Custom header should not succeed"
      );
      // Ensure that searching with the same Custom header succeeds.
      return test.cache.match(
        new Request(requestURL, { headers: { Custom: "foo=bar" } })
      );
    })
    .then(function (r) {
      return checkResponse(r, test.response, test.responseText);
    });
}

function testInvalidHeaderName() {
  var test;
  return setupTest({ WhatToVary: "Foo/Bar, Custom-User-Agent" })
    .then(function (t) {
      test = t;
      // Ensure that searching with a different User-Agent header fails.
      return test.cache.match(
        new Request(requestURL, { headers: { "Custom-User-Agent": "MyUA" } })
      );
    })
    .then(function (r) {
      is(
        typeof r,
        "undefined",
        "Searching for a request with a non-matching Custom-User-Agent header should not succeed"
      );
      // Ensure that searching with a different Custom-User-Agent header but with ignoreVary succeeds.
      return test.cache.match(
        new Request(requestURL, { headers: { "Custom-User-Agent": "MyUA" } }),
        { ignoreVary: true }
      );
    })
    .then(function (r) {
      return checkResponse(r, test.response, test.responseText);
    })
    .then(function () {
      // Ensure that we do not mistakenly recognize the tokens in the invalid header name.
      return test.cache.match(
        new Request(requestURL, { headers: { Foo: "foobar" } })
      );
    })
    .then(function (r) {
      return checkResponse(r, test.response, test.responseText);
    });
}

function testMultipleHeaders() {
  var test;
  return setupTest({ WhatToVary: "Custom-Referer,\tCustom-Accept-Encoding" })
    .then(function (t) {
      test = t;
      // Ensure that searching with a different Referer header fails.
      return test.cache.match(
        new Request(requestURL, {
          headers: { "Custom-Referer": "https://somesite.com/" },
        })
      );
    })
    .then(function (r) {
      is(
        typeof r,
        "undefined",
        "Searching for a request with a non-matching Custom-Referer header should not succeed"
      );
      // Ensure that searching with a different Custom-Referer header but with ignoreVary succeeds.
      return test.cache.match(
        new Request(requestURL, {
          headers: { "Custom-Referer": "https://somesite.com/" },
        }),
        { ignoreVary: true }
      );
    })
    .then(function (r) {
      return checkResponse(r, test.response, test.responseText);
    })
    .then(function () {
      // Ensure that searching with a different Custom-Accept-Encoding header fails.
      return test.cache.match(
        new Request(requestURL, {
          headers: { "Custom-Accept-Encoding": "myencoding" },
        })
      );
    })
    .then(function (r) {
      is(
        typeof r,
        "undefined",
        "Searching for a request with a non-matching Custom-Accept-Encoding header should not succeed"
      );
      // Ensure that searching with a different Custom-Accept-Encoding header but with ignoreVary succeeds.
      return test.cache.match(
        new Request(requestURL, {
          headers: { "Custom-Accept-Encoding": "myencoding" },
        }),
        { ignoreVary: true }
      );
    })
    .then(function (r) {
      return checkResponse(r, test.response, test.responseText);
    })
    .then(function () {
      // Ensure that searching with an empty Custom-Referer header succeeds.
      return test.cache.match(
        new Request(requestURL, { headers: { "Custom-Referer": "" } })
      );
    })
    .then(function (r) {
      return checkResponse(r, test.response, test.responseText);
    })
    .then(function () {
      // Ensure that searching with an empty Custom-Accept-Encoding header succeeds.
      return test.cache.match(
        new Request(requestURL, { headers: { "Custom-Accept-Encoding": "" } })
      );
    })
    .then(function (r) {
      return checkResponse(r, test.response, test.responseText);
    })
    .then(function () {
      // Ensure that searching with an empty Custom-Referer header but with a different Custom-Accept-Encoding header fails.
      return test.cache.match(
        new Request(requestURL, {
          headers: {
            "Custom-Referer": "",
            "Custom-Accept-Encoding": "myencoding",
          },
        })
      );
    })
    .then(function (r) {
      is(
        typeof r,
        "undefined",
        "Searching for a request with a non-matching Custom-Accept-Encoding header should not succeed"
      );
      // Ensure that searching with an empty Custom-Referer header but with a different Custom-Accept-Encoding header and ignoreVary succeeds.
      return test.cache.match(
        new Request(requestURL, {
          headers: {
            "Custom-Referer": "",
            "Custom-Accept-Encoding": "myencoding",
          },
        }),
        { ignoreVary: true }
      );
    })
    .then(function (r) {
      return checkResponse(r, test.response, test.responseText);
    });
}

function testMultipleCacheEntries() {
  var test;
  return setupTestMultipleEntries([
    { WhatToVary: "Accept-Language", "Accept-Language": "en-US" },
    { WhatToVary: "Accept-Language", "Accept-Language": "en-US, fa-IR" },
  ])
    .then(function (t) {
      test = t;
      return test.cache.matchAll();
    })
    .then(function (r) {
      is(r.length, 2, "Two cache entries should be stored in the DB");
      // Ensure that searching without specifying an Accept-Language header fails.
      return test.cache.matchAll(requestURL);
    })
    .then(function (r) {
      is(
        r.length,
        0,
        "Searching for a request without specifying an Accept-Language header should not succeed"
      );
      // Ensure that searching without specifying an Accept-Language header but with ignoreVary succeeds.
      return test.cache.matchAll(requestURL, { ignoreVary: true });
    })
    .then(function (r) {
      return Promise.all([
        checkResponse(r[0], test.response[0], test.responseText[0]),
        checkResponse(r[1], test.response[1], test.responseText[1]),
      ]);
    })
    .then(function () {
      // Ensure that searching with Accept-Language: en-US succeeds.
      return test.cache.matchAll(
        new Request(requestURL, { headers: { "Accept-Language": "en-US" } })
      );
    })
    .then(function (r) {
      is(r.length, 1, "One cache entry should be found");
      return checkResponse(r[0], test.response[0], test.responseText[0]);
    })
    .then(function () {
      // Ensure that searching with Accept-Language: en-US,fa-IR succeeds.
      return test.cache.matchAll(
        new Request(requestURL, {
          headers: { "Accept-Language": "en-US, fa-IR" },
        })
      );
    })
    .then(function (r) {
      is(r.length, 1, "One cache entry should be found");
      return checkResponse(r[0], test.response[1], test.responseText[1]);
    })
    .then(function () {
      // Ensure that searching with a valid Accept-Language header but with ignoreVary returns both entries.
      return test.cache.matchAll(
        new Request(requestURL, { headers: { "Accept-Language": "en-US" } }),
        { ignoreVary: true }
      );
    })
    .then(function (r) {
      return Promise.all([
        checkResponse(r[0], test.response[0], test.responseText[0]),
        checkResponse(r[1], test.response[1], test.responseText[1]),
      ]);
    })
    .then(function () {
      // Ensure that searching with Accept-Language: fa-IR fails.
      return test.cache.matchAll(
        new Request(requestURL, { headers: { "Accept-Language": "fa-IR" } })
      );
    })
    .then(function (r) {
      is(
        r.length,
        0,
        "Searching for a request with a different Accept-Language header should not succeed"
      );
      // Ensure that searching with Accept-Language: fa-IR but with ignoreVary should succeed.
      return test.cache.matchAll(
        new Request(requestURL, { headers: { "Accept-Language": "fa-IR" } }),
        { ignoreVary: true }
      );
    })
    .then(function (r) {
      is(r.length, 2, "Two cache entries should be found");
      return Promise.all([
        checkResponse(r[0], test.response[0], test.responseText[0]),
        checkResponse(r[1], test.response[1], test.responseText[1]),
      ]);
    });
}

// Make sure to clean up after each test step.
function step(testPromise) {
  return testPromise.then(
    function () {
      caches.delete(name);
    },
    function () {
      caches.delete(name);
    }
  );
}

step(testBasics())
  .then(function () {
    return step(testBasicKeys());
  })
  .then(function () {
    return step(testStar());
  })
  .then(function () {
    return step(testMatch());
  })
  .then(function () {
    return step(testInvalidHeaderName());
  })
  .then(function () {
    return step(testMultipleHeaders());
  })
  .then(function () {
    return step(testMultipleCacheEntries());
  })
  .then(function () {
    testDone();
  });
