export function findElementPaths(
  node: React.ReactNode,
  curPath: string = ''
): string[] {
  if (Array.isArray(node)) {
    return flatten(
      node.map((child, idx) => findElementPaths(child, `${curPath}[${idx}]`))
    );
  }

  if (!isElement(node)) {
    // At this point the node can be null, boolean, string, number, Portal, etc.
    // https://github.com/facebook/flow/blob/172d28f542f49bbc1e765131c9dfb9e31780f3a2/lib/react.js#L13-L20
    return [];
  }

  const element = node as React.ReactElement<any>;
  const { children } = element.props;

  const childElPaths =
    // Props of elements returned by render functions can't be read here
    typeof children !== 'function'
      ? findElementPaths(children, getChildrenPath(curPath))
      : [];

  // Ignore Fragment elements, but include their children
  return element.type === Fragment ? childElPaths : [curPath, ...childElPaths];
}

export function getElementAtPath(
  node: React.ReactNode,
  elPath: string
): null | React.ReactElement<any> {
  if (!isElement(node) && !Array.isArray(node)) {
    return null;
  }

  const rootNode = node as React.ReactElement<any> | React.ReactNode[];
  const childNode = isRootPath(elPath) ? rootNode : get(rootNode, elPath);

  if (!isElement(childNode)) {
    return null;
  }

  return childNode as React.ReactElement<any>;
}

export function isMultiFixture(
  fixtureExport: ReactFixtureExport
): fixtureExport is ReactFixtureMap {
  return (
    fixtureExport !== null &&
    typeof fixtureExport === 'object' &&
    !isElement(fixtureExport)
  );
}

// Don't compare private element attrs like _owner and _store, which hold
// internal details and have auto increment-type attrs
function stripInternalElementAttrs(node: React.ReactNode): {} {
  if (Array.isArray(node)) {
    return node.map(n => stripInternalElementAttrs(n));
  }
  if (!isElement(node)) {
    return node;
  }

  const el = node as React.ReactElement<any>;
  return {
    ...pick(el, 'type', 'key', 'ref'),
    // children and other props can contain Elements
    props: mapValues(el.props, propValue =>
      stripInternalElementAttrs(propValue)
    )
  };
}

function cloneNode(value: React.ReactNode): React.ReactNode {
  if (Array.isArray(value)) {
    return value.map(n => cloneNode(n));
  }

  if (isElement(value)) {
    const el = value as React.ReactElement<any>;
    const { children, ...otherProps } = el.props;

    return {
      ...el,
      props: {
        ...otherProps,
        children: cloneNode(children)
      }
    };
  }

  return value;
}

function stringifyValue(key: string, value: unknown): FixtureStateValue {
  try {
    // NOTE: Is this optimal?
    if (!isEqual(JSON.parse(JSON.stringify(value)), value)) {
      throw new Error('Unserializable value');
    }
  } catch (err) {
    return {
      serializable: false,
      key,
      // TODO: Enable custom stringifiers to plug in
      stringified: isElement(value)
        ? reactElementToJSXString(value)
        : String(value)
    };
  }

  return {
    serializable: true,
    key,
    stringified: JSON.stringify(value)
  };
}

export const test = (val: any) => val && ReactIs.isElement(val);