/*
  Copyright 2018 Google LLC

  Use of this source code is governed by an MIT-style
  license that can be found in the LICENSE file or at
  https://opensource.org/licenses/MIT.
*/

import '../../_version.js';

interface LoggableObject {
  [key: string]: string | number;
}
interface MessageMap {
  [messageID: string]: (param: LoggableObject) => string;
}

export const messages: MessageMap = {
  'invalid-value': ({paramName, validValueDescription, value}) => {
    if (!paramName || !validValueDescription) {
      throw new Error(`Unexpected input to 'invalid-value' error.`);
    }
    return (
      `The '${paramName}' parameter was given a value with an ` +
      `unexpected value. ${validValueDescription} Received a value of ` +
      `${JSON.stringify(value)}.`
    );
  },

  'not-an-array': ({moduleName, className, funcName, paramName}) => {
    if (!moduleName || !className || !funcName || !paramName) {
      throw new Error(`Unexpected input to 'not-an-array' error.`);
    }
    return (
      `The parameter '${paramName}' passed into ` +
      `'${moduleName}.${className}.${funcName}()' must be an array.`
    );
  },

  'incorrect-type': ({
    expectedType,
    paramName,
    moduleName,
    className,
    funcName,
  }) => {
    if (!expectedType || !paramName || !moduleName || !funcName) {
      throw new Error(`Unexpected input to 'incorrect-type' error.`);
    }
    const classNameStr = className ? `${className}.` : '';
    return (
      `The parameter '${paramName}' passed into ` +
      `'${moduleName}.${classNameStr}` +
      `${funcName}()' must be of type ${expectedType}.`
    );
  },

  'incorrect-class': ({
    expectedClassName,
    paramName,
    moduleName,
    className,
    funcName,
    isReturnValueProblem,
  }) => {
    if (!expectedClassName || !moduleName || !funcName) {
      throw new Error(`Unexpected input to 'incorrect-class' error.`);
    }
    const classNameStr = className ? `${className}.` : '';
    if (isReturnValueProblem) {
      return (
        `The return value from ` +
        `'${moduleName}.${classNameStr}${funcName}()' ` +
        `must be an instance of class ${expectedClassName}.`
      );
    }

    return (
      `The parameter '${paramName}' passed into ` +
      `'${moduleName}.${classNameStr}${funcName}()' ` +
      `must be an instance of class ${expectedClassName}.`
    );
  },

  'missing-a-method': ({
    expectedMethod,
    paramName,
    moduleName,
    className,
    funcName,
  }) => {
    if (
      !expectedMethod ||
      !paramName ||
      !moduleName ||
      !className ||
      !funcName
    ) {
      throw new Error(`Unexpected input to 'missing-a-method' error.`);
    }
    return (
      `${moduleName}.${className}.${funcName}() expected the ` +
      `'${paramName}' parameter to expose a '${expectedMethod}' method.`
    );
  },

  'add-to-cache-list-unexpected-type': ({entry}) => {
    return (
      `An unexpected entry was passed to ` +
      `'workbox-precaching.PrecacheController.addToCacheList()' The entry ` +
      `'${JSON.stringify(
        entry,
      )}' isn't supported. You must supply an array of ` +
      `strings with one or more characters, objects with a url property or ` +
      `Request objects.`
    );
  },

  'add-to-cache-list-conflicting-entries': ({firstEntry, secondEntry}) => {
    if (!firstEntry || !secondEntry) {
      throw new Error(
        `Unexpected input to ` + `'add-to-cache-list-duplicate-entries' error.`,
      );
    }

    return (
      `Two of the entries passed to ` +
      `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` +
      `${firstEntry} but different revision details. Workbox is ` +
      `unable to cache and version the asset correctly. Please remove one ` +
      `of the entries.`
    );
  },

  'plugin-error-request-will-fetch': ({thrownErrorMessage}) => {
    if (!thrownErrorMessage) {
      throw new Error(
        `Unexpected input to ` + `'plugin-error-request-will-fetch', error.`,
      );
    }

    return (
      `An error was thrown by a plugins 'requestWillFetch()' method. ` +
      `The thrown error message was: '${thrownErrorMessage}'.`
    );
  },

  'invalid-cache-name': ({cacheNameId, value}) => {
    if (!cacheNameId) {
      throw new Error(
        `Expected a 'cacheNameId' for error 'invalid-cache-name'`,
      );
    }

    return (
      `You must provide a name containing at least one character for ` +
      `setCacheDetails({${cacheNameId}: '...'}). Received a value of ` +
      `'${JSON.stringify(value)}'`
    );
  },

  'unregister-route-but-not-found-with-method': ({method}) => {
    if (!method) {
      throw new Error(
        `Unexpected input to ` +
          `'unregister-route-but-not-found-with-method' error.`,
      );
    }

    return (
      `The route you're trying to unregister was not  previously ` +
      `registered for the method type '${method}'.`
    );
  },

  'unregister-route-route-not-registered': () => {
    return (
      `The route you're trying to unregister was not previously ` +
      `registered.`
    );
  },

  'queue-replay-failed': ({name}) => {
    return `Replaying the background sync queue '${name}' failed.`;
  },

  'duplicate-queue-name': ({name}) => {
    return (
      `The Queue name '${name}' is already being used. ` +
      `All instances of backgroundSync.Queue must be given unique names.`
    );
  },

  'expired-test-without-max-age': ({methodName, paramName}) => {
    return (
      `The '${methodName}()' method can only be used when the ` +
      `'${paramName}' is used in the constructor.`
    );
  },

  'unsupported-route-type': ({moduleName, className, funcName, paramName}) => {
    return (
      `The supplied '${paramName}' parameter was an unsupported type. ` +
      `Please check the docs for ${moduleName}.${className}.${funcName} for ` +
      `valid input types.`
    );
  },

  'not-array-of-class': ({
    value,
    expectedClass,
    moduleName,
    className,
    funcName,
    paramName,
  }) => {
    return (
      `The supplied '${paramName}' parameter must be an array of ` +
      `'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` +
      `Please check the call to ${moduleName}.${className}.${funcName}() ` +
      `to fix the issue.`
    );
  },

  'max-entries-or-age-required': ({moduleName, className, funcName}) => {
    return (
      `You must define either config.maxEntries or config.maxAgeSeconds` +
      `in ${moduleName}.${className}.${funcName}`
    );
  },

  'statuses-or-headers-required': ({moduleName, className, funcName}) => {
    return (
      `You must define either config.statuses or config.headers` +
      `in ${moduleName}.${className}.${funcName}`
    );
  },

  'invalid-string': ({moduleName, funcName, paramName}) => {
    if (!paramName || !moduleName || !funcName) {
      throw new Error(`Unexpected input to 'invalid-string' error.`);
    }
    return (
      `When using strings, the '${paramName}' parameter must start with ` +
      `'http' (for cross-origin matches) or '/' (for same-origin matches). ` +
      `Please see the docs for ${moduleName}.${funcName}() for ` +
      `more info.`
    );
  },

  'channel-name-required': () => {
    return (
      `You must provide a channelName to construct a ` +
      `BroadcastCacheUpdate instance.`
    );
  },

  'invalid-responses-are-same-args': () => {
    return (
      `The arguments passed into responsesAreSame() appear to be ` +
      `invalid. Please ensure valid Responses are used.`
    );
  },

  'expire-custom-caches-only': () => {
    return (
      `You must provide a 'cacheName' property when using the ` +
      `expiration plugin with a runtime caching strategy.`
    );
  },

  'unit-must-be-bytes': ({normalizedRangeHeader}) => {
    if (!normalizedRangeHeader) {
      throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);
    }
    return (
      `The 'unit' portion of the Range header must be set to 'bytes'. ` +
      `The Range header provided was "${normalizedRangeHeader}"`
    );
  },

  'single-range-only': ({normalizedRangeHeader}) => {
    if (!normalizedRangeHeader) {
      throw new Error(`Unexpected input to 'single-range-only' error.`);
    }
    return (
      `Multiple ranges are not supported. Please use a  single start ` +
      `value, and optional end value. The Range header provided was ` +
      `"${normalizedRangeHeader}"`
    );
  },

  'invalid-range-values': ({normalizedRangeHeader}) => {
    if (!normalizedRangeHeader) {
      throw new Error(`Unexpected input to 'invalid-range-values' error.`);
    }
    return (
      `The Range header is missing both start and end values. At least ` +
      `one of those values is needed. The Range header provided was ` +
      `"${normalizedRangeHeader}"`
    );
  },

  'no-range-header': () => {
    return `No Range header was found in the Request provided.`;
  },

  'range-not-satisfiable': ({size, start, end}) => {
    return (
      `The start (${start}) and end (${end}) values in the Range are ` +
      `not satisfiable by the cached response, which is ${size} bytes.`
    );
  },

  'attempt-to-cache-non-get-request': ({url, method}) => {
    return (
      `Unable to cache '${url}' because it is a '${method}' request and ` +
      `only 'GET' requests can be cached.`
    );
  },

  'cache-put-with-no-response': ({url}) => {
    return (
      `There was an attempt to cache '${url}' but the response was not ` +
      `defined.`
    );
  },

  'no-response': ({url, error}) => {
    let message = `The strategy could not generate a response for '${url}'.`;
    if (error) {
      message += ` The underlying error is ${error}.`;
    }
    return message;
  },

  'bad-precaching-response': ({url, status}) => {
    return (
      `The precaching request for '${url}' failed` +
      (status ? ` with an HTTP status of ${status}.` : `.`)
    );
  },

  'non-precached-url': ({url}) => {
    return (
      `createHandlerBoundToURL('${url}') was called, but that URL is ` +
      `not precached. Please pass in a URL that is precached instead.`
    );
  },

  'add-to-cache-list-conflicting-integrities': ({url}) => {
    return (
      `Two of the entries passed to ` +
      `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` +
      `${url} with different integrity values. Please remove one of them.`
    );
  },

  'missing-precache-entry': ({cacheName, url}) => {
    return `Unable to find a precached response in ${cacheName} for ${url}.`;
  },

  'cross-origin-copy-response': ({origin}) => {
    return (
      `workbox-core.copyResponse() can only be used with same-origin ` +
      `responses. It was passed a response with origin ${origin}.`
    );
  },

  'opaque-streams-source': ({type}) => {
    const message =
      `One of the workbox-streams sources resulted in an ` +
      `'${type}' response.`;
    if (type === 'opaqueredirect') {
      return (
        `${message} Please do not use a navigation request that results ` +
        `in a redirect as a source.`
      );
    }
    return `${message} Please ensure your sources are CORS-enabled.`;
  },
};