// ✅ Streaming partial JSON accumulator
// file: apps/web/src/lib/PartialJsonParser.ts

import { repairTruncatedJson } from '../../../gateway/src/gateway/JsonAstRepair'

export class PartialJsonParser<T> {
  private buffer = ''
  private lastValidSnapshot: Partial<T> | null = null

  feed(chunk: string): Partial<T> | null {
    this.buffer += chunk

    // Attempt to parse the current buffer as-is
    try {
      const result = JSON.parse(this.buffer) as T
      this.lastValidSnapshot = result
      return result
    } catch {
      // Buffer is incomplete — try repair
      const repaired = repairTruncatedJson(this.buffer)
      try {
        const partial = JSON.parse(repaired) as Partial<T>
        this.lastValidSnapshot = partial
        return partial
      } catch {
        // Not yet parseable at all — return last valid snapshot
        return this.lastValidSnapshot
      }
    }
  }

  reset(): void {
    this.buffer = ''
    this.lastValidSnapshot = null
  }
}

// ✅ Version-vector canvas store with conflict resolution
// file: apps/web/src/stores/CanvasStore.ts

export interface CanvasNode {
  id: string
  label: string
  nodeType: 'component' | 'service' | 'database' | 'queue'
  position: { x: number; y: number }
  version: number          // Monotonic counter
  lockedBy: 'human' | 'ai' | null  // Current lock holder
  lockedAt: number | null  // Lock timestamp (ms)
}

const LOCK_TIMEOUT_MS = 5_000  // AI lock expires after 5s of silence

export class CanvasStore {
  private nodes = new Map<string, CanvasNode>()
  private listeners = new Set<() => void>()

  // Human edit — always wins if node is not AI-locked, or lock has expired
  humanUpdate(id: string, patch: Partial<CanvasNode>): boolean {
    const node = this.nodes.get(id)
    if (!node) return false

    // Check if AI holds an active lock on this node
    if (node.lockedBy === 'ai' && node.lockedAt !== null) {
      const lockAge = Date.now() - node.lockedAt
      if (lockAge < LOCK_TIMEOUT_MS) {
        // AI is actively writing this node — queue human edit for after lock release
        return false
      }
    }

    this.nodes.set(id, {
      ...node,
      ...patch,
      version: node.version + 1,
      lockedBy: null,
      lockedAt: null,
    })
    this.notify()
    return true
  }

  // AI streaming update — respects human locks
  aiStreamUpdate(id: string, partial: Partial<CanvasNode>): void {
    const existing = this.nodes.get(id)

    if (!existing) {
      // New node from AI — materialise with streaming lock
      this.nodes.set(id, {
        id,
        label: partial.label ?? '',
        nodeType: partial.nodeType ?? 'component',
        position: partial.position ?? { x: 0, y: 0 },
        version: 1,
        lockedBy: 'ai',
        lockedAt: Date.now(),
        ...partial,
      })
    } else {
      // Check if human holds lock
      if (existing.lockedBy === 'human') {
        // Human is actively editing — AI cannot overwrite
        return
      }

      this.nodes.set(id, {
        ...existing,
        ...partial,
        version: existing.version + 1,
        lockedBy: 'ai',
        lockedAt: Date.now(),
      })
    }

    this.notify()
  }

  // Called when AI finishes streaming a node — release lock
  aiCommitNode(id: string, finalNode: CanvasNode): void {
    const existing = this.nodes.get(id)
    if (!existing || existing.lockedBy !== 'ai') return

    this.nodes.set(id, {
      ...finalNode,
      version: (existing.version ?? 0) + 1,
      lockedBy: null,
      lockedAt: null,
    })
    this.notify()
  }

  subscribe(listener: () => void): () => void {
    this.listeners.add(listener)
    return () => this.listeners.delete(listener)
  }

  getSnapshot(): ReadonlyMap<string, CanvasNode> {
    return this.nodes
  }

  private notify(): void {
    this.listeners.forEach(l => l())
  }
}

// ✅ Canvas node that renders progressive AI streaming state
// file: apps/web/src/features/canvas/CanvasNodeCard.tsx

import { useSyncExternalStore } from 'react'

interface Props {
  nodeId: string
  store: CanvasStore
}

export function CanvasNodeCard({ nodeId, store }: Props) {
  const snapshot = useSyncExternalStore(
    store.subscribe.bind(store),
    store.getSnapshot.bind(store),
    store.getSnapshot.bind(store),
  )
  const node = snapshot.get(nodeId)

  if (!node) return null

  const isStreaming = node.lockedBy === 'ai'
  const isHumanEditing = node.lockedBy === 'human'

  return (
    <div
      className={[
        'canvas-node',
        isStreaming ? 'canvas-node--streaming' : '',
        isHumanEditing ? 'canvas-node--human-editing' : '',
      ].join(' ')}
      data-node-type={node.nodeType}
      data-version={node.version}
    >
      {isStreaming && <span className="streaming-indicator" aria-label="AI is writing" />}
      {isHumanEditing && <span className="human-indicator" aria-label="You are editing" />}

      <NodeLabel
        value={node.label}
        isEditable={!isStreaming}
        onEdit={(label) => store.humanUpdate(nodeId, { label, lockedBy: 'human', lockedAt: Date.now() })}
        onBlur={() => store.humanUpdate(nodeId, { lockedBy: null, lockedAt: null })}
      />
      <NodeTypeBadge type={node.nodeType} />
      <span className="node-version" title="Version">v{node.version}</span>
    </div>
  )
}

// ✅ SSE event dispatcher that routes AI actions to canvas vs chat
// file: apps/web/src/features/canvas/AiActionDispatcher.ts

import { GatewayActionSchema } from '@workspace/ai-schemas'
import { CanvasStore } from '../stores/CanvasStore'
import { StreamingMessageStore } from '../stores/StreamingMessageStore'

export class AiActionDispatcher {
  private partialNodeParsers = new Map<string, PartialJsonParser<CanvasNode>>()

  constructor(
    private readonly canvasStore: CanvasStore,
    private readonly messageStore: StreamingMessageStore,
  ) {}

  dispatch(rawEventData: string): void {
    if (rawEventData === '[DONE]') {
      // Commit all in-flight streaming nodes
      this.partialNodeParsers.forEach((_, id) => {
        const node = this.canvasStore.getSnapshot().get(id)
        if (node && node.lockedBy === 'ai') {
          this.canvasStore.aiCommitNode(id, node)
        }
      })
      this.partialNodeParsers.clear()
      return
    }

    const action = GatewayActionSchema.safeParse(JSON.parse(rawEventData))
    if (!action.success) return

    switch (action.data.type) {
      case 'canvas_node':
        this.handleCanvasNode(action.data.payload)
        break
      case 'text_reply':
        this.messageStore.appendToken(action.data.payload.content)
        break
      case 'tool_call':
        // Handled by the agent layer (Part 15)
        break
    }
  }

  private handleCanvasNode(partial: Partial<CanvasNode>): void {
    if (!partial.id) return
    let parser = this.partialNodeParsers.get(partial.id)
    if (!parser) {
      parser = new PartialJsonParser<CanvasNode>()
      this.partialNodeParsers.set(partial.id, parser)
    }
    this.canvasStore.aiStreamUpdate(partial.id, partial)
  }
}