physical-expo/lib/api.ts

import { API_CONFIG, API_ENDPOINTS } from "@/constants/api";
import {
  ApiListResponse,
  ApiResponse,
  Country,
  League,
  Match,
  MatchDetailData,
  Sport,
  UpcomingMatch,
} from "@/types/api";
import axios from "axios";

const apiClient = axios.create({
  baseURL: API_CONFIG.BASE_URL,
  timeout: API_CONFIG.TIMEOUT,
  headers: {
    "Content-Type": "application/json",
  },
});

export const fetchSports = async (): Promise<Sport[]> => {
  try {
    const response = await apiClient.get<ApiResponse<ApiListResponse<Sport>>>(
      API_ENDPOINTS.SPORTS
    );
    if (response.data.code === 0) {
      return response.data.data.list;
    }
    throw new Error(response.data.message);
  } catch (error) {
    console.error("Fetch sports error:", error);
    // Do not return mock data here — rethrow to let caller handle the error
    throw error;
  }
};

export const fetchCountries = async (): Promise<Country[]> => {
  try {
    const response = await apiClient.get<ApiResponse<ApiListResponse<Country>>>(
      API_ENDPOINTS.COUNTRIES
    );
    if (response.data.code === 0) {
      return response.data.data.list;
    }
    throw new Error(response.data.message);
  } catch (error) {
    console.error("Fetch countries error:", error);
    throw error;
  }
};

export const fetchLeagues = async (
  sportId: number,
  countryKey: string
): Promise<League[]> => {
  try {
    const response = await apiClient.get<ApiResponse<ApiListResponse<League>>>(
      API_ENDPOINTS.LEAGUES,
      {
        params: {
          sportId,
          countryKey,
        },
      }
    );
    if (response.data.code === 0) {
      return response.data.data.list;
    }
    throw new Error(response.data.message);
  } catch (error) {
    console.error("Fetch leagues error:", error);
    throw error;
  }
};

export const fetchTodayMatches = async (sportId: number): Promise<Match[]> => {
  try {
    const response = await apiClient.get<ApiResponse<ApiListResponse<Match>>>(
      API_ENDPOINTS.MATCHES_TODAY,
      {
        params: { sport_id: sportId },
      }
    );
    if (response.data.code === 0) {
      return response.data.data.list;
    }
    throw new Error(response.data.message);
  } catch (error) {
    console.error("Fetch matches error:", error);
    // Let the caller handle errors; rethrow the original error
    throw error;
  }
};

export const fetchMatchDetail = async (
  id: string
): Promise<MatchDetailData> => {
  try {
    const response = await apiClient.get<ApiResponse<MatchDetailData>>(
      API_ENDPOINTS.MATCH_DETAIL(id)
    );
    if (response.data.code === 0) {
      return response.data.data;
    }
    throw new Error(response.data.message);
  } catch (error) {
    console.error("Fetch match detail error:", error);
    throw error;
  }
};

export const fetchUpcomingMatches = async (
  sportId: number,
  leagueKey: string,
  limit: number = 50
): Promise<UpcomingMatch[]> => {
  try {
    const response =
      await apiClient.get<ApiResponse<ApiListResponse<UpcomingMatch>>>(
        API_ENDPOINTS.UPCOMING_MATCHES,
        {
          params: {
            sport_id: sportId,
            leagueKey,
            limit,
          },
        }
      );

    if (response.data.code === 0) {
      return response.data.data.list;
    }

    throw new Error(response.data.message);
  } catch (error) {
    console.error("Fetch upcoming matches error:", error);
    throw error;
  }
};