export function applyValue(nextPropsOrEmpty, dom, mounting: boolean) {
  const value = nextPropsOrEmpty.value;
  const domValue = dom.value;

  if (isNullOrUndef(value)) {
    if (mounting) {
      const defaultValue = nextPropsOrEmpty.defaultValue;

      if (!isNullOrUndef(defaultValue)) {
        if (defaultValue !== domValue) {
          dom.defaultValue = defaultValue;
          dom.value = defaultValue;
        }
      } else if (domValue !== "") {
        dom.defaultValue = "";
        dom.value = "";
      }
    }
  } else {
    /* There is value so keep it controlled */
    if (domValue !== value) {
      dom.defaultValue = value;
      dom.value = value;
    }
  }
}

// We are assuming here that we come from patchProp routine
// -nextAttrValue cannot be null or undefined
function patchStyle(lastAttrValue, nextAttrValue, dom) {
  const domStyle = dom.style;
  let style;
  let value;

  if (isString(nextAttrValue)) {
    domStyle.cssText = nextAttrValue;
    return;
  }

  if (!isNullOrUndef(lastAttrValue) && !isString(lastAttrValue)) {
    for (style in nextAttrValue) {
      // do not add a hasOwnProperty check here, it affects performance
      value = nextAttrValue[style];
      if (value !== lastAttrValue[style]) {
        domStyle[style] =
          !isNumber(value) || isUnitlessNumber.has(style)
            ? value
            : value + "px";
      }
    }

    for (style in lastAttrValue) {
      if (isNullOrUndef(nextAttrValue[style])) {
        domStyle[style] = "";
      }
    }
  } else {
    for (style in nextAttrValue) {
      value = nextAttrValue[style];
      domStyle[style] =
        !isNumber(value) || isUnitlessNumber.has(style) ? value : value + "px";
    }
  }
}

export function applyValue(nextPropsOrEmpty, dom) {
  const type = nextPropsOrEmpty.type;
  const value = nextPropsOrEmpty.value;
  const checked = nextPropsOrEmpty.checked;
  const multiple = nextPropsOrEmpty.multiple;
  const defaultValue = nextPropsOrEmpty.defaultValue;
  const hasValue = !isNullOrUndef(value);

  if (type && type !== dom.type) {
    dom.setAttribute("type", type);
  }
  if (multiple && multiple !== dom.multiple) {
    dom.multiple = multiple;
  }
  if (!isNullOrUndef(defaultValue) && !hasValue) {
    dom.defaultValue = defaultValue + "";
  }
  if (isCheckedType(type)) {
    if (hasValue) {
      dom.value = value;
    }
    if (!isNullOrUndef(checked)) {
      dom.checked = checked;
    }
  } else {
    if (hasValue && dom.value !== value) {
      dom.defaultValue = value;
      dom.value = value;
    } else if (!isNullOrUndef(checked)) {
      dom.checked = checked;
    }
  }
}

export function isKeyed(lastChildren: VNode[], nextChildren: VNode[]): boolean {
  return (
    nextChildren.length > 0 &&
    !isNullOrUndef(nextChildren[0]) &&
    !isNullOrUndef(nextChildren[0].key) &&
    lastChildren.length > 0 &&
    !isNullOrUndef(lastChildren[0]) &&
    !isNullOrUndef(lastChildren[0].key)
  );
}

options.createVNode = (vNode: VNode): void => {
  const children = vNode.children;
  let props = vNode.props;

  if (isNullOrUndef(props)) {
    props = vNode.props = {};
  }
  if (!isNullOrUndef(children) && isNullOrUndef(props.children)) {
    props.children = children;
  }
  if (oldCreateVNode) {
    oldCreateVNode(vNode);
  }
};

export function mountFunctionalComponentCallbacks(
  props,
  ref,
  dom,
  lifecycle: LifecycleClass
) {
  if (ref) {
    if (!isNullOrUndef(ref.onComponentWillMount)) {
      ref.onComponentWillMount(props);
    }
    if (!isNullOrUndef(ref.onComponentDidMount)) {
      lifecycle.addListener(() => ref.onComponentDidMount(dom, props));
    }
  }
}

function updateChildOption(vNode, value) {
  const props = vNode.props || EMPTY_OBJ;
  const dom = vNode.dom;

  // we do this as multiple may have changed
  dom.value = props.value;
  if (
    (isArray(value) && value.indexOf(props.value) !== -1) ||
    props.value === value
  ) {
    dom.selected = true;
  } else if (!isNullOrUndef(value) || !isNullOrUndef(props.selected)) {
    dom.selected = props.selected || false;
  }
}

export function validateNodeTree(node: any): boolean {
  if (!node) {
    return true;
  }
  if (isStringOrNumber(node)) {
    return true;
  }
  if (!node.dom) {
    return false;
  }
  const children = node.children;
  const flags = node.flags;

  if ((flags & VNodeFlags.Element) > 0) {
    if (!isNullOrUndef(children)) {
      if (isArray(children)) {
        for (const child of children) {
          const val = validateNodeTree(child);

          if (!val) {
            return false;
          }
        }
      } else {
        const val = validateNodeTree(children);

        if (!val) {
          return false;
        }
      }
    }
  }
  return true;
}

export function insertOrAppend(parentDom, newNode, nextNode) {
  if (isNullOrUndef(nextNode)) {
    appendChild(parentDom, newNode);
  } else {
    parentDom.insertBefore(newNode, nextNode);
  }
}

export function patchEvent(name: string, lastValue, nextValue, dom) {
  if (lastValue !== nextValue) {
    if (delegatedEvents.has(name)) {
      handleEvent(name, lastValue, nextValue, dom);
    } else {
      const nameLowerCase = name.toLowerCase();
      const domEvent = dom[nameLowerCase];
      // if the function is wrapped, that means it's been controlled by a wrapper
      if (domEvent && domEvent.wrapped) {
        return;
      }
      if (!isFunction(nextValue) && !isNullOrUndef(nextValue)) {
        const linkEvent = nextValue.event;

        if (linkEvent && isFunction(linkEvent)) {
          dom[nameLowerCase] = function(e) {
            linkEvent(nextValue.data, e);
          };
        } else {
          if (process.env.NODE_ENV !== "production") {
            throwError(
              `an event on a VNode "${name}". was not a function or a valid linkEvent.`
            );
          }
          throwError();
        }
      } else {
        dom[nameLowerCase] = nextValue;
      }
    }
  }
}