import {ChunkType} from "../chunks/types/ChunkType";
import {NodeImplChunk} from "../chunks/types/NodeImplChunk";
import {childNodeChunkToChildNodeProps} from "./childNodeChunkToChildNodeProps";
import {childNodesChunkToChildNodesProps} from "./childNodesChunkToChildNodesProps";
import {connectionChunkToConnection} from "./connectionChunkToConnection";
import {connectionsChunkToConnectionArray} from "./connectionsChunkToConnectionArray";
import {dependenciesChunkToDependencyDef} from "./dependenciesChunkToDependencyDef";
import {dependencyChunkToDependencyDef} from "./dependencyChunkToDependencyDef";
import {portExposureChunkToChildPortRef} from "./portExposureChunkToChildPortRef";
import {portExposuresChunkToExposedPorts} from "./portExposuresChunkToExposedPorts";
import {ChildNodesProps} from "./types/ChildNodesProps";
import {Connection} from "./types/Connection";
import {DependencyDef} from "./types/DependencyDef";
import {PortDirection} from "./types/PortDirection";
import {PortExposures} from "./types/PortExposures";
import {StructureNodeDef} from "./types/StructureNodeDef";
import {getChildNameFromChildNodeChunk} from "./utils/getChildNameFromChildNodeChunk";
import {getOwnPortNameFromPortExposureChunk} from "./utils/getOwnPortNameFromPortExposureChunk";
import {getPortDirectionFromPortExposureChunk} from "./utils/getPortDirectionFromPortExposureChunk";

export function nodeImplChunkToStructureNodeDef(
  nodeImplChunk: NodeImplChunk
): Partial<StructureNodeDef<any, any, any>> {
  const childNodesProps: ChildNodesProps<any, any> = {};
  const dependencies = [] as Array<DependencyDef>;
  const connections = [] as Array<Connection<any, any, any>>;
  const exposedInputs = {} as PortExposures<any, any, any>;
  const exposedOutputs = {} as PortExposures<any, any, any>;
  const {children = []} = nodeImplChunk;
  for (const chunk of children) {
    switch (chunk.type) {
    case ChunkType.ChildNodes:
      Object.assign(
        childNodesProps,
        childNodesChunkToChildNodesProps(chunk));
      break;
    case ChunkType.ChildNode:
      const childName = getChildNameFromChildNodeChunk(chunk);
      const childNodeProps =
        childNodeChunkToChildNodeProps(chunk);
      if (childNodeProps) {
        childNodesProps[childName] = childNodeProps;
      }
      break;
    case ChunkType.Connections:
      const connectionGroup = connectionsChunkToConnectionArray(chunk);
      for (const connection of connectionGroup) {
        connections.push(connection);
      }
      break;
    case ChunkType.Connection:
      const connection = connectionChunkToConnection(chunk);
      if (connection) {
        connections.push(connection);
      }
      break;
    case ChunkType.Dependency:
      const dependency = dependencyChunkToDependencyDef(chunk);
      dependencies.push(dependency);
      break;
    case ChunkType.Dependencies:
      const dependencyGroup = dependenciesChunkToDependencyDef(chunk);
      for (const dependency of dependencyGroup) {
        dependencies.push(dependency);
      }
      break;
    case ChunkType.PortExposures:
      const {
        exposedInputs: exposedInputGroup,
        exposedOutputs: exposedOutputGroup
      } = portExposuresChunkToExposedPorts(chunk);
      Object.assign(exposedInputs, exposedInputGroup);
      Object.assign(exposedOutputs, exposedOutputGroup);
      break;
    case ChunkType.PortExposure:
      const portName = getOwnPortNameFromPortExposureChunk(chunk);
      const portDirection = getPortDirectionFromPortExposureChunk(chunk);
      switch (portDirection) {
      case PortDirection.input:
        exposedInputs[portName] = portExposureChunkToChildPortRef(chunk);
        break;
      case PortDirection.output:
        exposedOutputs[portName] = portExposureChunkToChildPortRef(chunk);
        break;
      }
      break;
    }
  }
  return {
    childNodesProps,
    connections,
    dependencies,
    exposedInputs,
    exposedOutputs
  };
}