import { useState } from 'react';
import { Brokle } from 'brokle';

const client = new Brokle({ apiKey: 'bk_...' });

function FeedbackButtons({ traceId, userId }) {
  const [submitted, setSubmitted] = useState(false);

  const submitFeedback = async (score: 1 | -1) => {
    await client.feedback({
      traceId,
      score,
      userId
    });
    setSubmitted(true);
  };

  if (submitted) {
    return <span>Thanks for your feedback!</span>;
  }

  return (
    <div className="flex gap-2">
      <button onClick={() => submitFeedback(1)}>👍</button>
      <button onClick={() => submitFeedback(-1)}>👎</button>
    </div>
  );
}

function FeedbackWithComment({ traceId, userId }) {
  const [showModal, setShowModal] = useState(false);
  const [comment, setComment] = useState('');
  const [category, setCategory] = useState('');

  const submitNegativeFeedback = async () => {
    await client.feedback({
      traceId,
      score: -1,
      userId,
      comment,
      category
    });
    setShowModal(false);
  };

  return (
    <>
      <button onClick={() => submitFeedback(1)}>👍</button>
      <button onClick={() => setShowModal(true)}>👎</button>

      {showModal && (
        <Modal onClose={() => setShowModal(false)}>
          <select value={category} onChange={e => setCategory(e.target.value)}>
            <option value="">What went wrong?</option>
            <option value="inaccurate">Inaccurate information</option>
            <option value="irrelevant">Not relevant to my question</option>
            <option value="incomplete">Missing information</option>
            <option value="other">Other</option>
          </select>

          <textarea
            value={comment}
            onChange={e => setComment(e.target.value)}
            placeholder="Tell us more (optional)"
          />

          <button onClick={submitNegativeFeedback}>Submit</button>
        </Modal>
      )}
    </>
  );
}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from brokle import Brokle

app = FastAPI()
client = Brokle()

class FeedbackRequest(BaseModel):
    trace_id: str
    score: int  # 1 or -1
    comment: str | None = None
    category: str | None = None

@app.post("/api/feedback")
async def submit_feedback(req: FeedbackRequest, user_id: str = Depends(get_user)):
    try:
        client.feedback(
            trace_id=req.trace_id,
            score=req.score,
            user_id=user_id,
            comment=req.comment,
            category=req.category
        )
        return {"success": True}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

from datetime import datetime, timedelta

# Get daily satisfaction rates
daily_stats = client.get_feedback_aggregations(
    project_id="proj_123",
    start_time=datetime.now() - timedelta(days=30),
    group_by="day"
)

for day in daily_stats:
    positive = day.positive_count
    total = day.positive_count + day.negative_count
    rate = positive / total if total > 0 else 0
    print(f"{day.date}: {rate:.1%} ({total} ratings)")

# Get feedback by category
category_stats = client.get_feedback_by_category(
    project_id="proj_123",
    start_time=datetime.now() - timedelta(days=7)
)

print("Top issues:")
for cat in sorted(category_stats, key=lambda x: x.count, reverse=True):
    print(f"  {cat.category}: {cat.count} complaints")

# Get feedback grouped by model
model_stats = client.get_feedback_stats(
    project_id="proj_123",
    group_by="model"
)

for model in model_stats:
    print(f"{model.name}: {model.satisfaction_rate:.1%}")

# Find traces with negative feedback
problem_traces = client.list_traces(
    project_id="proj_123",
    filters={"feedback_score": {"lt": 0}},
    limit=50
)

for trace in problem_traces:
    print(f"Trace: {trace.id}")
    print(f"Input: {trace.input[:100]}...")
    print(f"Feedback: {trace.feedback[0].comment}")
    print("---")

# Tag traces with experiment variant
with client.start_as_current_span(name="chat") as span:
    span.update_trace(metadata={"experiment": "prompt_v2"})
    response = llm.generate(prompt_v2)

# Later: Compare feedback by variant
variants = ["prompt_v1", "prompt_v2"]
for variant in variants:
    stats = client.get_feedback_stats(
        project_id="proj_123",
        filters={"metadata.experiment": variant}
    )
    print(f"{variant}: {stats.satisfaction_rate:.1%}")

// Good: Always visible
<div className="flex items-center gap-4">
  <div className="ai-response">{response}</div>
  <FeedbackButtons traceId={traceId} />
</div>

// Bad: Hidden in dropdown
<DropdownMenu>
  <MenuItem>Rate this response</MenuItem>
</DropdownMenu>

if score < 0:
    # Prompt for more information
    client.feedback(
        trace_id=trace_id,
        score=score,
        category=selected_category,
        comment=user_comment,
        metadata={
            "input_length": len(input),
            "output_length": len(output),
            "model": model_name
        }
    )

total_traces = client.count_traces(project_id, time_range)
traces_with_feedback = client.count_traces(
    project_id,
    time_range,
    filters={"has_feedback": True}
)

feedback_rate = traces_with_feedback / total_traces
print(f"Feedback rate: {feedback_rate:.1%}")