// ✅ Blackboard memory — shared PostgreSQL facts table
// file: src/agents/Blackboard.ts

import { db } from '../../packages/db/src/drizzle'
import { pgTable, uuid, text, timestamp, jsonb } from 'drizzle-orm/pg-core'

export const blackboardFacts = pgTable('blackboard_facts', {
  id:         uuid('id').primaryKey().defaultRandom(),
  sessionId:  uuid('session_id').notNull(),
  agentId:    text('agent_id').notNull(),
  factType:   text('fact_type').notNull(),  // Typed as FactType in application layer
  content:    text('content').notNull(),
  metadata:   jsonb('metadata'),
  createdAt:  timestamp('created_at').defaultNow(),
})

// Type-safe fact type enum — keeps blackboard writes consistent across agents.
// In production, validate with z.enum([...]) before every deposit() call.
export type FactType = 'research_finding' | 'schema_decision' | 'review_comment' | 'concurrency_lock'

export class Blackboard {
  constructor(private sessionId: string) {}

  async deposit(agentId: string, factType: FactType, content: string, metadata?: unknown): Promise<void> {
    await db.insert(blackboardFacts).values({
      sessionId: this.sessionId,
      agentId,
      factType,
      content,
      metadata: metadata as any,
    })
  }

  async read(factType?: FactType): Promise<{ agentId: string; factType: FactType; content: string }[]> {
    const query = db.select({
      agentId: blackboardFacts.agentId,
      factType: blackboardFacts.factType,
      content: blackboardFacts.content,
    }).from(blackboardFacts)
    .where(eq(blackboardFacts.sessionId, this.sessionId))
    .orderBy(asc(blackboardFacts.createdAt))

    const results = await (factType
      ? query.where(eq(blackboardFacts.factType, factType))
      : query)

    return results as { agentId: string; factType: FactType; content: string }[]
  }

  async summarise(): Promise<string> {
    const facts = await this.read()
    return facts
      .map(f => `[${f.agentId}/${f.factType}]: ${f.content}`)
      .join('\n')
  }
}

// ✅ Researcher Agent — narrow focus, dedicated tools
// file: src/agents/ResearcherAgent.ts

export class ResearcherAgent {
  private runtime: FsmAgentRuntime

  constructor(orgId: string, private blackboard: Blackboard) {
    this.runtime = new FsmAgentRuntime({
      maxSteps: 8,
      maxTokensPerStep: 2048,
      systemPrompt: `You are a Technical Researcher. Your ONLY job is to search the 
knowledge vault and deposit verified findings on the blackboard. 
Do not draft documents. Do not design schemas. Only research and report.`,
      tools: [
        searchKnowledgeTool(orgId),          // Can read knowledge vault
        depositBlackboardTool(blackboard),   // Can write to blackboard
      ],
      requireHumanApproval: () => false,
    })
  }

  async research(topic: string): Promise<void> {
    await this.runtime.run(
      `Research topic: "${topic}". Search the knowledge vault thoroughly. ` +
      `Deposit each significant finding on the blackboard with factType "research_finding".`
    )
  }
}

// ✅ Schema Engineer Agent — reads blackboard, designs, writes canvas
export class SchemaEngineerAgent {
  private runtime: FsmAgentRuntime

  constructor(orgId: string, private blackboard: Blackboard) {
    this.runtime = new FsmAgentRuntime({
      maxSteps: 12,
      maxTokensPerStep: 3072,
      systemPrompt: `You are a Database Schema Engineer. You read research findings from 
the blackboard and design database schemas. Create canvas nodes for each table.
Do not perform research. Do not write prose. Only design schemas.`,
      tools: [
        readBlackboardTool(blackboard),         // Can read findings
        createCanvasNodeTool(orgId),            // Can write canvas
        depositBlackboardTool(blackboard),      // Can deposit schema decisions
      ],
      requireHumanApproval: (tool) => tool === 'deploy_schema',  // Gate deployments
    })
  }

  async design(task: string): Promise<void> {
    const findings = await this.blackboard.summarise()
    await this.runtime.run(
      `Design database schema for: "${task}".\n\nResearch findings:\n${findings}`
    )
  }
}

// ✅ Supervisor — coordinates agents, enforces sequencing
// file: src/agents/SupervisorOrchestrator.ts

export class SupervisorOrchestrator {
  constructor(
    private orgId: string,
    private canvasStore: CanvasStore,
  ) {}

  async run(task: string, sessionId: string): Promise<OrchestratorResult> {
    const blackboard = new Blackboard(sessionId)

    // Phase 1: Research (parallel-safe — read-only canvas)
    const researcher = new ResearcherAgent(this.orgId, blackboard)
    await researcher.research(task)

    // Phase 2: Schema design (sequential — writes canvas)
    // Acquire canvas write lock before allowing SchemaEngineerAgent to proceed
    const schemaLockAcquired = this.canvasStore.acquireAgentLock('schema-engineer')
    if (!schemaLockAcquired) {
      throw new Error('Canvas is locked by another agent — retry later')
    }

    try {
      const schemaEngineer = new SchemaEngineerAgent(this.orgId, blackboard)
      await schemaEngineer.design(task)
    } finally {
      this.canvasStore.releaseAgentLock('schema-engineer')
    }

    // Phase 3: Review (read-only — can run after schema engineer releases lock)
    const reviewer = new ReviewerAgent(this.orgId, blackboard)
    const reviewComments = await reviewer.review(task)

    return {
      sessionId,
      blackboardSummary: await blackboard.summarise(),
      reviewComments,
    }
  }
}

// Extension to CanvasStore from Part 7 — agent lock management
export class CanvasStore {
  private agentLocks = new Map<string, { agentId: string; acquiredAt: number }>()
  private AGENT_LOCK_TIMEOUT = 30_000  // 30 seconds

  acquireAgentLock(agentId: string): boolean {
    const existing = this.agentLocks.get('canvas')
    if (existing) {
      const isStale = Date.now() - existing.acquiredAt > this.AGENT_LOCK_TIMEOUT
      if (!isStale) return false  // Canvas locked by another active agent
    }
    this.agentLocks.set('canvas', { agentId, acquiredAt: Date.now() })
    return true
  }

  releaseAgentLock(agentId: string): void {
    const lock = this.agentLocks.get('canvas')
    if (lock?.agentId === agentId) {
      this.agentLocks.delete('canvas')
    }
  }
}