/** @typedef {import("ajv").Ajv} Ajv */
/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
/** @typedef {import("../validate").SchemaUtilErrorObject} SchemaUtilErrorObject */

/**
 * @param {string} message
 * @param {object} schema
 * @param {string} data
 * @returns {SchemaUtilErrorObject}
 */
function errorMessage(message, schema, data) {
  return {
    // @ts-ignore
    // eslint-disable-next-line no-undefined
    dataPath: undefined,
    // @ts-ignore
    // eslint-disable-next-line no-undefined
    schemaPath: undefined,
    keyword: "absolutePath",
    params: { absolutePath: data },
    message,
    parentSchema: schema,
  };
}

/**
 * @param {boolean} shouldBeAbsolute
 * @param {object} schema
 * @param {string} data
 * @returns {SchemaUtilErrorObject}
 */
function getErrorFor(shouldBeAbsolute, schema, data) {
  const message = shouldBeAbsolute
    ? `The provided value ${JSON.stringify(data)} is not an absolute path!`
    : `A relative path is expected. However, the provided value ${JSON.stringify(
        data
      )} is an absolute path!`;

  return errorMessage(message, schema, data);
}

/**
 *
 * @param {Ajv} ajv
 * @returns {Ajv}
 */
function addAbsolutePathKeyword(ajv) {
  ajv.addKeyword("absolutePath", {
    errors: true,
    type: "string",
    compile(schema, parentSchema) {
      /** @type {ValidateFunction} */
      const callback = (data) => {
        let passes = true;
        const isExclamationMarkPresent = data.includes("!");

        if (isExclamationMarkPresent) {
          callback.errors = [
            errorMessage(
              `The provided value ${JSON.stringify(
                data
              )} contains exclamation mark (!) which is not allowed because it's reserved for loader syntax.`,
              parentSchema,
              data
            ),
          ];
          passes = false;
        }

        // ?:[A-Za-z]:\\ - Windows absolute path
        // \\\\ - Windows network absolute path
        // \/ - Unix-like OS absolute path
        const isCorrectAbsolutePath =
          schema === /^(?:[A-Za-z]:(\\|\/)|\\\\|\/)/.test(data);

        if (!isCorrectAbsolutePath) {
          callback.errors = [getErrorFor(schema, parentSchema, data)];
          passes = false;
        }

        return passes;
      };

      callback.errors = [];

      return callback;
    },
  });

  return ajv;
}

export default addAbsolutePathKeyword;
