User/src/services/issueService.ts

import { API_BASE_URL } from "../config/supabase";
import { Issue, IssueListResponse, LocationData } from "../types";
import EventSource, { EventSourceListener } from "react-native-sse";
import { cacheService } from "./cacheService";

class IssueService {
  private baseUrl: string;

  constructor() {
    this.baseUrl = API_BASE_URL;
  }

  async createIssue(
    imageUri: string,
    location: LocationData,
    description?: string,
    accessToken?: string,
  ): Promise<{ issue_id: string; stream_url: string }> {
    const formData = new FormData();

    const imageFile = {
      uri: imageUri,
      type: "image/jpeg",
      name: "issue_photo.jpg",
    } as any;

    formData.append("images", imageFile);
    formData.append("latitude", location.latitude.toString());
    formData.append("longitude", location.longitude.toString());
    formData.append("accuracy_meters", location.accuracy.toString());
    formData.append("platform", "mobile_app");
    formData.append("device_model", "expo_device");

    if (description) {
      formData.append("description", description);
    }

    if (accessToken) {
      formData.append("authorization", `Bearer ${accessToken}`);
      console.log("[IssueService] Authorization token appended to form data");
    } else {
      console.warn("[IssueService] No access token provided - issue will be created without user_id");
    }

    const headers: Record<string, string> = {
      "Content-Type": "multipart/form-data",
    };

    const response = await fetch(`${this.baseUrl}/issues/stream`, {
      method: "POST",
      headers,
      body: formData,
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.detail || "Failed to create issue");
    }

    await cacheService.clearCache();

    return response.json();
  }

  async getIssue(issueId: string): Promise<Issue> {
    const response = await fetch(`${this.baseUrl}/issues/${issueId}`);

    if (!response.ok) {
      throw new Error("Failed to fetch issue");
    }

    return response.json();
  }

  async listIssues(
    page: number = 1,
    pageSize: number = 20,
    state?: string,
    userId?: string,
  ): Promise<IssueListResponse> {
    const params = new URLSearchParams({
      page: page.toString(),
      page_size: pageSize.toString(),
    });

    if (state) {
      params.append("state", state);
    }

    if (userId) {
      params.append("user_id", userId);
    }

    const response = await fetch(`${this.baseUrl}/issues?${params}`);

    if (!response.ok) {
      throw new Error("Failed to fetch issues");
    }

    return response.json();
  }

  async connectToFlowStream(
    issueId: string,
    onMessage: (data: any) => void,
    onError: (error: Error) => void,
  ): Promise<() => void> {
    const eventSource = new EventSource(`${this.baseUrl}/flow/flow/${issueId}`);

    const listener: EventSourceListener = (event) => {
      if (event.type === "message") {
        try {
          const data = JSON.parse(event.data || "{}");
          onMessage(data);
        } catch (e) {
          console.error("Failed to parse SSE message:", e);
        }
      } else if (event.type === "error") {
        onError(new Error("SSE connection error"));
      }
    };

    eventSource.addEventListener("message", listener);
    eventSource.addEventListener("error", listener);

    return () => {
      eventSource.removeAllEventListeners();
      eventSource.close();
    };
  }
  async confirmIssue(issueId: string, confirmed: boolean): Promise<Issue> {
    const response = await fetch(`${this.baseUrl}/issues/${issueId}/confirm`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ confirmed }),
    });

    if (!response.ok) {
      throw new Error("Failed to confirm issue");
    }

    return response.json();
  }
}

export const issueService = new IssueService();