import {CompilationTargetId} from "../../types/CompilationTargetId";
import {isTargetIdCompatible} from "../../utils/isTargetIdCompatible";
import {ChunkType} from "../chunks/types/ChunkType";
import {NodeChunk} from "../chunks/types/NodeChunk";
import {nodeImplChunkToCodeNodeDef} from "./nodeImplChunkToCodeNodeDef";
import {nodeImplChunkToStructureNodeDef} from "./nodeImplChunkToStructureNodeDef";
import {NodeDef} from "./types/NodeDef";
import {getDirectionFromPortChunk} from "./utils/getDirectionFromPortChunk";
import {getDirectionFromPortsChunk} from "./utils/getDirectionFromPortsChunk";
import {getPortNameFromPortChunk} from "./utils/getPortNameFromPortChunk";
import {getPortNameFromPortsItemChunk} from "./utils/getPortNameFromPortsItemChunk";
import {getSpreadOpFromPortChunk} from "./utils/getSpreadOpFromPortChunk";
import {getSpreadOpFromPortsItemChunk} from "./utils/getSpreadOpFromPortsItemChunk";
import {getTargetIdFromNodeImplChunk} from "./utils/getTargetIdFromNodeImplChunk";
import {isCodeNodeImplChunk} from "./utils/isCodeNodeImplChunk";
import {isStructureNodeImplChunk} from "./utils/isStructureNodeImplChunk";

export function nodeChunkToNodeDef(
  nodeChunk: NodeChunk,
  targetId: CompilationTargetId
): NodeDef<any, any> {
  const {children = []} = nodeChunk;
  const inputNames: Array<string> = [];
  const outputNames: Array<string> = [];
  const spreadInputNames: Array<string> = [];
  const spreadOutputNames: Array<string> = [];
  let result = {
    inputNames,
    outputNames,
    spreadInputNames,
    spreadOutputNames
  } as NodeDef<any, any>;
  for (const chunk of children) {
    switch (chunk.type) {
    case ChunkType.NodeImpl:
      const foundTargetId = getTargetIdFromNodeImplChunk(chunk);
      if (foundTargetId && isTargetIdCompatible(targetId, foundTargetId)) {
        if (isCodeNodeImplChunk(chunk)) {
          Object.assign(
            result,
            nodeImplChunkToCodeNodeDef(chunk));
        } else if (isStructureNodeImplChunk(chunk)) {
          Object.assign(
            result,
            nodeImplChunkToStructureNodeDef(chunk));
        }
      }
      break;
    case ChunkType.Ports:
      const portsDirection = getDirectionFromPortsChunk(chunk);
      const {children = []} = chunk;
      for (const chunk of children) {
        if (chunk.type === ChunkType.PortsItem) {
          const spreadOp = getSpreadOpFromPortsItemChunk(chunk);
          const portName = getPortNameFromPortsItemChunk(chunk);
          switch (portsDirection) {
          case "inputs":
            if (spreadOp) {
              spreadInputNames.push(portName);
            } else {
              inputNames.push(portName);
            }
            break;
          case "outputs":
            if (spreadOp) {
              spreadOutputNames.push(portName);
            } else {
              outputNames.push(portName);
            }
            break;
          }
        }
      }
      break;
    case ChunkType.Port:
      const portDirection = getDirectionFromPortChunk(chunk);
      const spreadOp = getSpreadOpFromPortChunk(chunk);
      const portName = getPortNameFromPortChunk(chunk);
      switch (portDirection) {
      case "input":
        if (spreadOp) {
          spreadInputNames.push(portName);
        } else {
          inputNames.push(portName);
        }
        break;
      case "output":
        if (spreadOp) {
          spreadOutputNames.push(portName);
        } else {
          outputNames.push(portName);
        }
        break;
      }
      break;
    }
  }
  return result;
}