// lib/api-client.ts
const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3001/api';

class ApiClient {
  private baseURL: string;

  constructor() {
    this.baseURL = API_BASE_URL;
  }

  async uploadPDF(file: File): Promise<UploadResponse> {
    const formData = new FormData();
    formData.append('file', file);

    const response = await fetch(`${this.baseURL}/upload`, {
      method: 'POST',
      body: formData,
    });

    if (!response.ok) {
      throw new Error('Upload failed');
    }

    return response.json();
  }

  async generateQuiz(uploadId: string): Promise<QuizResponse> {
    const response = await fetch(`${this.baseURL}/quiz/generate`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ uploadId, questionCount: 5 }),
    });

    if (!response.ok) {
      throw new Error('Quiz generation failed');
    }

    return response.json();
  }

  async getQuiz(quizId: string): Promise<QuizData> {
    const response = await fetch(`${this.baseURL}/quiz/${quizId}`);
    
    if (!response.ok) {
      throw new Error('Failed to fetch quiz');
    }

    return response.json();
  }

  async submitQuiz(quizId: string, answers: Answer[]): Promise<QuizResult> {
    const response = await fetch(`${this.baseURL}/quiz/${quizId}/submit`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ answers }),
    });

    if (!response.ok) {
      throw new Error('Failed to submit quiz');
    }

    return response.json();
  }
}

export const apiClient = new ApiClient();

// lib/types.ts
export interface UploadResponse {
  success: boolean;
  data: {
    uploadId: string;
    filename: string;
    extractedText: string;
    processingStatus: string;
  };
}

export interface QuizResponse {
  success: boolean;
  data: {
    quizId: string;
    title: string;
    questions: Question[];
  };
}

export interface QuizResult {
  success: boolean;
  data: {
    score: number;
    totalQuestions: number;
    results: {
      questionId: string;
      correct: boolean;
      explanation: string;
    }[];
  };
}

// ...existing types...

// app/page.tsx (key changes)
const generateQuiz = async () => {
  if (!file) {
    toast.error("Please upload a PDF file first");
    return;
  }

  setIsUploading(true);
  
  try {
    // Upload PDF
    const uploadResponse = await apiClient.uploadPDF(file);
    
    // Generate quiz
    const quizResponse = await apiClient.generateQuiz(uploadResponse.data.uploadId);
    
    // Store quiz ID for navigation
    localStorage.setItem('currentQuizId', quizResponse.data.quizId);
    localStorage.setItem('quizData', JSON.stringify(quizResponse.data));
    
    toast.success("Quiz generated successfully!");
    router.push("/quiz");
  } catch (error) {
    toast.error("Failed to generate quiz. Please try again.");
    console.error('Quiz generation error:', error);
  } finally {
    setIsUploading(false);
  }
};

// app/quiz/page.tsx (key changes)
useEffect(() => {
  const loadQuiz = async () => {
    const quizId = localStorage.getItem('currentQuizId');
    
    if (quizId) {
      try {
        const quizData = await apiClient.getQuiz(quizId);
        setQuizData(quizData);
      } catch (error) {
        console.error('Failed to load quiz:', error);
        toast.error("Failed to load quiz");
        router.push("/");
      }
    } else {
      toast.error("No quiz found. Please upload a PDF first.");
      router.push("/");
    }
  };

  loadQuiz();
}, [router]);

// Submit quiz to backend when completed
const handleQuizSubmit = async () => {
  try {
    const quizId = localStorage.getItem('currentQuizId');
    const result = await apiClient.submitQuiz(quizId!, answers);
    
    // Update UI with results
    setQuizResults(result.data);
    setQuizCompleted(true);
  } catch (error) {
    console.error('Failed to submit quiz:', error);
    toast.error("Failed to submit quiz");
  }
};