export default class CodeReviewer extends AgenticSystem {
  @field issues = stream<string>('');
  @field suggestions = stream<string>('');
  @field improvedCode = stream<string>('');
  @field status: 'idle' | 'reviewing' = 'idle';

  @action()
  async review(code: string) {
    this.status = 'reviewing';
    await this.analyzeCode(code);
    this.status = 'idle';
  }
}

@action()
async review(code: string) {
  this.status = 'reviewing';

  // First: stream issues
  for await (const chunk of this.findIssues(code)) {
    this.issues.append(chunk);
  }
  this.issues.complete();

  // Second: stream suggestions based on issues
  for await (const chunk of ai.stream(`Suggest fixes for:\n${this.issues.current}`)) {
    this.suggestions.append(chunk);
  }
  this.suggestions.complete();

  // Third: stream improved code
  for await (const chunk of ai.stream(`Improve:\n${code}`)) {
    this.improvedCode.append(chunk);
  }
  this.improvedCode.complete();

  this.status = 'idle';
}

export default class ResearchSynthesizer extends AgenticSystem {
  @field summaries: Array<{ source: string; content: StreamableValue<string> }> = [];
  @field synthesis = stream<string>('');
  @field status: 'idle' | 'summarizing' | 'synthesizing' = 'idle';

  @action()
  async synthesize(sources: string[]) {
    this.status = 'summarizing';

    // Create streams for each source
    this.summaries = sources.map(source => ({
      source,
      content: stream<string>(''),
    }));

    // Stream all in parallel
    await Promise.all(
      sources.map(async (source, i) => {
        for await (const chunk of ai.stream(`Summarize: ${source}`)) {
          this.summaries[i].content.append(chunk);
        }
        this.summaries[i].content.complete();
      })
    );

    // Then synthesize
    this.status = 'synthesizing';
    const allContent = this.summaries.map(s => s.content.current).join('\n\n');

    for await (const chunk of ai.stream(`Synthesize:\n${allContent}`)) {
      this.synthesis.append(chunk);
    }
    this.synthesis.complete();

    this.status = 'idle';
  }
}

function ResearchView() {
  const { summaries, synthesis, status } = useSystem<ResearchSynthesizer>();

  return (
    <div>
      <StatusBadge status={status} />

      <div className="summaries">
        {summaries.map((summary, i) => (
          <SummaryCard key={i} source={summary.source}>
            {summary.content.current}
            {summary.content.status === 'streaming' && <Cursor />}
          </SummaryCard>
        ))}
      </div>

      {synthesis.current && (
        <div className="synthesis">
          {synthesis.current}
          {synthesis.status === 'streaming' && <Cursor />}
        </div>
      )}
    </div>
  );
}

await Promise.allSettled(
  sources.map(async (source, i) => {
    try {
      await this.streamSource(source, i);
    } catch (e) {
      this.summaries[i].content.fail(e);
    }
  })
);

@field completedCount = 0;

// After each stream completes
this.summaries[i].content.complete();
this.completedCount++;