"use strict";

{
  window.GFACL = {
    logic: {},
  };
  if (window.GFACL.logic !== undefined) {
    console.debug("GFACL Logic already exists", GFACL);
  }

  window.GFACL_Logic = function (args) {
    console.debug("Setup GFACL_Logic", GFACL);
    //This will now be initalized each page load (so could be called multiple times in a single browser page if ajax is enabled)
    if (!args.formId) {
      console.warn("formid is required for GFACL_Logic", args);
      return;
    }

    if (window.GFACL.logic[args.formId] !== undefined) {
      console.warn("GFACL_Logic already exists for formId", args.formId);
      return;
    }

    // add the logic to the global object
    console.debug("setup GFACL_Logic", args, this);

    var self = this;

    // copy all args to current object: (list expected props)
    for (const prop in args) {
      if (args.hasOwnProperty(prop)) {
        self[prop] = args[prop];
      }
    }

    //self.formId = args.formId;

    self.doingLogic = false;

    gform.addAction(
      "gform_frontend_pages_evaluated",
      function (pages, formId, pageObject) {
        console.debug("gform_frontend_pages_evaluated", formId);
        if (formId == self.formId) {
          self.pageObject = pageObject;
        }
      }
    );

    self.is_value_match = function (isMatch, formId, rule) {
      if (formId != self.formId) {
        return isMatch;
      }

      if (rule.value == "__return_true") {
        isMatch = true;
      } else if (rule.value == "__return_false") {
        isMatch = false;
      }

      // console.debug("is_value_match", isMatch, formId, rule);
      return isMatch;
    };

    // add filter to allow for pre-evaluation of rules
    self.rule_pre_evaluation = function (rule, formId, conditionalLogic) {
      // console.debug("rule_pre_evaluation", rule, formId, conditionalLogic);
      if (
        formId != self.formId ||
        !rule ||
        rule.fieldId != "__adv_cond_logic"
      ) {
        return rule;
      }

      var logic = self.logic[rule.value];
      if (!logic) {
        console.warn("No advanced logic found for ", rule.value);
        return rule;
      }

      for (var i in logic.groups) {
        if (logic.groups.hasOwnProperty(i)) {
          var group = logic.groups[i];
          group.rules.forEach((r) => (r.value = String(r.value)));
          var action = gf_get_field_action(formId, group);
          if (action == "show" || action == "send") {
            rule.value = "__return_true";
            break;
          } else {
            rule.value = "__return_false";
          }
        }
      }
      rule.fieldId = "__adv_cond_logic-processed";

      return rule;
      //get the relevant logic
    };

    // do the magic

    self.getFieldIds = function () {
      var fieldIds = [];
      if (!self.logic) {
        return fieldIds;
      }

      Object.keys(self.logic).forEach(function (logickey) {
        if (!logickey.startsWith("field")) {
          return;
        } else {
          var fieldId = logickey.split("/")[1];
          if (fieldId && !self.pages?.includes?.(String(fieldId))) {
            fieldIds.push(fieldId);
          }
        }
      });
      return fieldIds;
    };

    /**
     * Initiate the logic and apply the rules to the form
     */
    self.init = function () {
      console.debug("init", self.formId, self.logic, self.pages);

      gform.addFilter("gform_rule_pre_evaluation", self.rule_pre_evaluation);
      gform.addFilter("gform_is_value_match", self.is_value_match);

      // var fieldIds = self.getFieldIds();
      // gf_apply_rules(self.formId, fieldIds, true);
    };
    self.init();
  };

  /**
   * @param {Number} formId
   * @param {Number|String} rawFieldId
   * @returns {String|Number} The Field Values
   */
  window.gfacl_get_field_values = function (formId, rawFieldId) {
    var $ = jQuery,
      fieldId = gformExtractFieldId(rawFieldId),
      inputIndex = gformExtractInputIndex(rawFieldId),
      isInputSpecific = inputIndex !== false,
      $inputs,
      formattedValues = new Array(),
      values = new Array();

    if (isInputSpecific) {
      $inputs = $(
        "#input_{0}_{1}_{2}".gformFormat(formId, fieldId, inputIndex)
      );
    } else {
      $inputs = $(
        'input[id="input_{0}_{1}"], input[id^="input_{0}_{1}_"], input[id^="choice_{0}_{1}_"], select#input_{0}_{1}, textarea#input_{0}_{1}'.gformFormat(
          formId,
          fieldId
        )
      );
    }

    var isCheckable =
      $.inArray($inputs.attr("type"), ["checkbox", "radio"]) !== -1;

    if (isCheckable) {
      $inputs.each(function () {
        var $input = jQuery(this);
        var theFieldValue = gf_get_value($input.val());

        // force an empty value for unchecked items
        if (!$input.is(":checked")) {
          theFieldValue = "";
          values.push("");
        }
        // if the 'other' choice is selected, get the value from the 'other' text input
        else if (fieldValue == "gf_other_choice") {
          theFieldValue = $(
            "#input_{0}_{1}_other".gformFormat(formId, fieldId)
          ).val();
        }
        values.push(theFieldValue);
      });
      //handle multiple values
    } else {
      // handle single values
      var val = gf_get_value($inputs.eq(0).val());
      values = val instanceof Array ? val : [val];
    }

    for (var i = 0; i < values.length; i++) {
      var hasLabel = values[i] ? values[i].indexOf("|") >= 0 : true,
        fieldValue = gf_get_value(values[i]);

      var fieldNumberFormat = gf_get_field_number_format(
        rawFieldId,
        formId,
        "value"
      );
      if (fieldNumberFormat && !hasLabel) {
        fieldValue = gf_format_number(fieldValue, fieldNumberFormat);
      }

      formattedValues.push(fieldValue);
    }

    return formattedValues;
  };

  /**
   * @deprecated
   * @param {*} formId
   * @param {*} rawFieldId
   */
  window.advLog_get_field_values = function (formId, rawFieldId) {
    return window.gfacl_get_field_values(formId, rawFieldId);
  };
}