import Base from "./base";
import Util from "./util";

const BaseInput = ($ => {
  const ClassName = {
    FORM_GROUP: "form-group",
    BMD_FORM_GROUP: "bmd-form-group",
    BMD_LABEL: "bmd-label",
    BMD_LABEL_STATIC: "bmd-label-static",
    BMD_LABEL_PLACEHOLDER: "bmd-label-placeholder",
    BMD_LABEL_FLOATING: "bmd-label-floating",
    HAS_DANGER: "has-danger",
    IS_FILLED: "is-filled",
    IS_FOCUSED: "is-focused",
    INPUT_GROUP: "input-group"
  };

  const Selector = {
    FORM_GROUP: `.${ClassName.FORM_GROUP}`,
    BMD_FORM_GROUP: `.${ClassName.BMD_FORM_GROUP}`,
    BMD_LABEL_WILDCARD: `label[class^='${ClassName.BMD_LABEL}'], label[class*=' ${ClassName.BMD_LABEL}']` // match any label variant if specified
  };

  const Default = {
    validate: false,
    formGroup: {
      required: false
    },
    bmdFormGroup: {
      template: `<span class='${ClassName.BMD_FORM_GROUP}'></span>`,
      create: true, // create a wrapper if form-group not found
      required: true // not recommended to turn this off, only used for inline components
    },
    label: {
      required: false,

      // Prioritized find order for resolving the label to be used as an bmd-label if not specified in the markup
      //  - a function(thisComponent); or
      //  - a string selector used like $bmdFormGroup.find(selector)
      //
      // Note this only runs if $bmdFormGroup.find(Selector.BMD_LABEL_WILDCARD) fails to find a label (as authored in the markup)
      //
      selectors: [
        `.form-control-label`, // in the case of horizontal or inline forms, this will be marked
        `> label` // usual case for text inputs, first child.  Deeper would find toggle labels so don't do that.
      ],
      className: ClassName.BMD_LABEL_STATIC
    },
    requiredClasses: [],
    invalidComponentMatches: [],
    convertInputSizeVariations: true
  };

  const FormControlSizeMarkers = {
    "form-control-lg": "bmd-form-group-lg",
    "form-control-sm": "bmd-form-group-sm"
  };

  /**
   * ------------------------------------------------------------------------
   * Class Definition
   * ------------------------------------------------------------------------
   */
  class BaseInput extends Base {
    /**
     *
     * @param element
     * @param config
     * @param properties - anything that needs to be set as this[key] = value.  Works around the need to call `super` before using `this`
     */
    constructor($element, config, properties = {}) {
      super($element, $.extend(true, {}, Default, config), properties);

      // Enforce no overlap between components to prevent side effects
      this._rejectInvalidComponentMatches();

      // Enforce expected structure (if any)
      this.rejectWithoutRequiredStructure();

      // Enforce required classes for a consistent rendering
      this._rejectWithoutRequiredClasses();

      // Resolve the form-group first, it will be used for bmd-form-group if possible
      //   note: different components have different rules
      this.$formGroup = this.findFormGroup(this.config.formGroup.required);

      // Will add bmd-form-group to form-group or create an bmd-form-group
      //  Performance Note: for those forms that are really performance driven, create the markup with the .bmd-form-group to avoid
      //    rendering changes once added.
      this.$bmdFormGroup = this.resolveMdbFormGroup();

      // Resolve and mark the bmdLabel if necessary as defined by the config
      this.$bmdLabel = this.resolveMdbLabel();

      // Signal to the bmd-form-group that a form-control-* variation is being used
      this.resolveMdbFormGroupSizing();

      this.addFocusListener();
      this.addChangeListener();

      if (this.$element.val() != "") {
        this.addIsFilled();
      }
    }

    dispose(dataKey) {
      super.dispose(dataKey);
      this.$bmdFormGroup = null;
      this.$formGroup = null;
    }

    // ------------------------------------------------------------------------
    // protected

    rejectWithoutRequiredStructure() {
      // implement
    }

    addFocusListener() {
      this.$element
        .on("focus", () => {
          this.addFormGroupFocus();
        })
        .on("blur", () => {
          this.removeFormGroupFocus();
        });
    }

    addChangeListener() {
      this.$element
        .on("keydown paste", event => {
          if (Util.isChar(event)) {
            this.addIsFilled();
          }
        })
        .on("keyup change", () => {
          // make sure empty is added back when there is a programmatic value change.
          //  NOTE: programmatic changing of value using $.val() must trigger the change event i.e. $.val('x').trigger('change')
          if (this.isEmpty()) {
            this.removeIsFilled();
          } else {
            this.addIsFilled();
          }

          if (this.config.validate) {
            // Validation events do not bubble, so they must be attached directly to the text: http://jsfiddle.net/PEpRM/1/
            //  Further, even the bind method is being caught, but since we are already calling #checkValidity here, just alter
            //  the form-group on change.
            //
            // NOTE: I'm not sure we should be intervening regarding validation, this seems better as a README and snippet of code.
            //        BUT, I've left it here for backwards compatibility.
            let isValid =
              typeof this.$element[0].checkValidity === "undefined" ||
              this.$element[0].checkValidity();
            if (isValid) {
              this.removeHasDanger();
            } else {
              this.addHasDanger();
            }
          }
        });
    }

    addHasDanger() {
      this.$bmdFormGroup.addClass(ClassName.HAS_DANGER);
    }

    removeHasDanger() {
      this.$bmdFormGroup.removeClass(ClassName.HAS_DANGER);
    }

    isEmpty() {
      return (
        this.$element.val() === null ||
        this.$element.val() === undefined ||
        this.$element.val() === ""
      );
    }

    // Will add bmd-form-group to form-group or create a bmd-form-group if necessary
    resolveMdbFormGroup() {
      let mfg = this.findMdbFormGroup(false);
      if (mfg === undefined || mfg.length === 0) {
        if (
          this.config.bmdFormGroup.create &&
          (this.$formGroup === undefined || this.$formGroup.length === 0)
        ) {
          // If a form-group doesn't exist (not recommended), take a guess and wrap the element (assuming no label).
          //  note: it's possible to make this smarter, but I need to see valid cases before adding any complexity.

          // this may be an input-group, wrap that instead
          if (this.outerElement().parent().hasClass(ClassName.INPUT_GROUP)) {
            this.outerElement()
              .parent()
              .wrap(this.config.bmdFormGroup.template);
          } else {
            this.outerElement().wrap(this.config.bmdFormGroup.template);
          }
        } else {
          // a form-group does exist, add our marker class to it
          this.$formGroup.addClass(ClassName.BMD_FORM_GROUP);

          // OLD: may want to implement this after all, see how the styling turns out, but using an existing form-group is less manipulation of the dom and therefore preferable
          // A form-group does exist, so add an bmd-form-group wrapping it's internal contents
          //fg.wrapInner(this.config.bmdFormGroup.template)
        }

        mfg = this.findMdbFormGroup(this.config.bmdFormGroup.required);
      }

      return mfg;
    }

    // Demarcation element (e.g. first child of a form-group)
    //  Subclasses such as file inputs may have different structures
    outerElement() {
      return this.$element;
    }

    // Will add bmd-label to bmd-form-group if not already specified
    resolveMdbLabel() {
      let label = this.$bmdFormGroup.find(Selector.BMD_LABEL_WILDCARD);
      if (label === undefined || label.length === 0) {
        // we need to find it based on the configured selectors
        label = this.findMdbLabel(this.config.label.required);

        if (label === undefined || label.length === 0) {
          // no label found, and finder did not require one
        } else {
          // a candidate label was found, add the configured default class name
          label.addClass(this.config.label.className);
        }
      }

      return label;
    }

    // Find bmd-label variant based on the config selectors
    findMdbLabel(raiseError = true) {
      let label = null;

      // use the specified selector order
      for (let selector of this.config.label.selectors) {
        if ($.isFunction(selector)) {
          label = selector(this);
        } else {
          label = this.$bmdFormGroup.find(selector);
        }

        if (label !== undefined && label.length > 0) {
          break;
        }
      }

      if (label.length === 0 && raiseError) {
        $.error(
          `Failed to find ${Selector.BMD_LABEL_WILDCARD} within form-group for ${Util.describe(
            this.$element
          )}`
        );
      }
      return label;
    }

    // Find bmd-form-group
    findFormGroup(raiseError = true) {
      let fg = this.$element.closest(Selector.FORM_GROUP);
      if (fg.length === 0 && raiseError) {
        $.error(
          `Failed to find ${Selector.FORM_GROUP} for ${Util.describe(
            this.$element
          )}`
        );
      }
      return fg;
    }

    // Due to the interconnected nature of labels/inputs/help-blocks, signal the bmd-form-group-* size variation based on
    //  a found form-control-* size
    resolveMdbFormGroupSizing() {
      if (!this.config.convertInputSizeVariations) {
        return;
      }

      // Modification - Change text-sm/lg to form-group-sm/lg instead (preferred standard and simpler css/less variants)
      for (let inputSize in FormControlSizeMarkers) {
        if (this.$element.hasClass(inputSize)) {
          //this.$element.removeClass(inputSize)
          this.$bmdFormGroup.addClass(FormControlSizeMarkers[inputSize]);
        }
      }
    }

    // ------------------------------------------------------------------------
    // private
    _rejectInvalidComponentMatches() {
      for (let otherComponent of this.config.invalidComponentMatches) {
        otherComponent.rejectMatch(this.constructor.name, this.$element);
      }
    }

    _rejectWithoutRequiredClasses() {
      for (let requiredClass of this.config.requiredClasses) {
        let found = false;
        // allow one of several classes to be passed in x||y
        if (requiredClass.indexOf("||") !== -1) {
          let oneOf = requiredClass.split("||");
          for (let requiredClass of oneOf) {
            if (this.$element.hasClass(requiredClass)) {
              found = true;
              break;
            }
          }
        } else if (this.$element.hasClass(requiredClass)) {
          found = true;
        }

        // error if not found
        if (!found) {
          $.error(
            `${this.constructor.name} element: ${Util.describe(
              this.$element
            )} requires class: ${requiredClass}`
          );
        }
      }
    }

    // ------------------------------------------------------------------------
    // static
  }

  return BaseInput;
})(jQuery);

export default BaseInput;