import type {
  InputPortKey,
  NodeId,
  NodeRef,
  OutputPortKey,
  RunnableNodeConfig,
  RunnableNodeOutputJson,
  UpstreamRefPlaceholder,
  WorkflowDefinition,
} from "../../types";

import type { DefinedNodeCredentialBindings } from "../../authoring/defineNode.types";
import type { DefinedHumanApprovalNode, HumanApprovalOutputJson } from "../../authoring/defineHumanApprovalNode.types";
import { WorkflowBuilder } from "./WorkflowBuilder";
import { ChainCursor } from "./ChainCursorResolver";
import type { AnyRunnableNodeConfig, BooleanWhenOverloads, ValidStepSequence } from "./workflowBuilderTypes";

type WhenEndpoint = Readonly<{ node: NodeRef; output: OutputPortKey; inputPortHint?: InputPortKey }>;

export class WhenBuilder<TCurrentJson> {
  private armEndpoint: WhenEndpoint | undefined;

  constructor(
    private readonly wf: WorkflowBuilder,
    private readonly from: NodeRef,
    private readonly branchPort: OutputPortKey,
    private readonly priorEndpoints: ReadonlyArray<WhenEndpoint> = [],
  ) {}

  addBranch<TSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(
    steps: TSteps & ValidStepSequence<TCurrentJson, TSteps>,
  ): this {
    const created: NodeRef[] = [];

    let prev: NodeRef | null = null;
    for (const cfg of steps) {
      const ref = (this.wf as any).add(cfg) as NodeRef;
      created.push(ref);
      if (!prev) (this.wf as any).connect(this.from, ref, this.branchPort, "in");
      else (this.wf as any).connect(prev, ref, "main", "in");
      prev = ref;
    }

    for (const cfg of steps) {
      const maybe = cfg as unknown as { upstreamRefs?: Array<{ nodeId: NodeId } | UpstreamRefPlaceholder> };
      if (!Array.isArray(maybe.upstreamRefs) || maybe.upstreamRefs.length === 0) continue;

      maybe.upstreamRefs = maybe.upstreamRefs.map((r) => {
        if (typeof r !== "string") return r;
        const idx = parseInt(r.slice(1), 10);
        const nodeId = created[idx]?.id;
        return nodeId ? { nodeId } : { nodeId: r };
      });
    }

    this.armEndpoint = prev
      ? { node: prev, output: "main", inputPortHint: this.branchPort }
      : { node: this.from, output: this.branchPort, inputPortHint: this.branchPort };

    return this;
  }

  readonly when: BooleanWhenOverloads<TCurrentJson, WhenBuilder<TCurrentJson>> = (
    branch: boolean,
    steps: ReadonlyArray<AnyRunnableNodeConfig> | AnyRunnableNodeConfig,
    ...more: AnyRunnableNodeConfig[]
  ): WhenBuilder<TCurrentJson> => {
    const list = Array.isArray(steps) ? steps : [steps, ...more];
    const port: OutputPortKey = branch ? "true" : "false";
    const b = new WhenBuilder<TCurrentJson>(this.wf, this.from, port, this.accumulatedEndpoints);
    b.addBranch(list);
    return b;
  };

  then<TOutputJson, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson>>(
    config: TConfig,
  ): ChainCursor<RunnableNodeOutputJson<TConfig>> {
    return this.toCursor().then(config);
  }

  humanApproval<
    TKey extends string,
    TConfig extends Record<string, unknown>,
    TBindings extends DefinedNodeCredentialBindings | undefined = undefined,
  >(
    node: DefinedHumanApprovalNode<TKey, TConfig, TCurrentJson & Record<string, unknown>, TBindings>,
    config: TConfig,
    metadata?: { name?: string; nodeId?: string },
  ): ChainCursor<HumanApprovalOutputJson<TCurrentJson & Record<string, unknown>>> {
    return this.toCursor().humanApproval(node, config, metadata);
  }

  build(): WorkflowDefinition {
    return this.wf.build();
  }

  private get accumulatedEndpoints(): ReadonlyArray<WhenEndpoint> {
    return this.armEndpoint ? [...this.priorEndpoints, this.armEndpoint] : this.priorEndpoints;
  }

  private toCursor(): ChainCursor<TCurrentJson> {
    return new ChainCursor<TCurrentJson>(this.wf, this.accumulatedEndpoints);
  }
}