import axios from 'npm:axios';
import { ApiError, NetworkError } from './errors.ts';

interface Post {
  id: number;
  title: string;
  body: string;
  userId: number;
}

interface User {
  id: number;
  username: string;
  email: string;
}

const apiClient = axios.create({
  baseURL: 'https://dummyjson.com',
  timeout: 2000,
});

apiClient.interceptors.response.use(
  (response) => {
    console.log('Interceptors response: ', response.data);

    response.data['timestamp'] = new Date();
    delete response.data['title'];

    return response;
  },
  (error) => {
    if (axios.isAxiosError(error)) {
      console.error(
        'Interceptors: Fehler ',
        error.response?.status,
        error.message
      );
    } else {
      console.error('Unbekannter Fehler', error);
    }

    return Promise.reject(error);
  }
);

async function fetchData<T>(endpoint: string): Promise<T> {
  try {
    const response = await apiClient.get<T>(endpoint);
    return response.data;
  } catch (error) {
    if (axios.isAxiosError(error)) {
      throw new ApiError(error.response?.status ?? 500, error.message);
    }

    throw new NetworkError(
      'Netzwerkfehler: ' +
        (error instanceof Error ? error.message : 'Unbekannt')
    );
  }
}

async function fetchPost(): Promise<void> {
  try {
    const post = await fetchData<Post>('/posts/1');
    console.log('Empfangene Daten', post.title);
  } catch (error) {
    console.log('Fehler beim Abrufen der Daten: ', error);
  }
}

fetchPost();

async function createPost(): Promise<void> {
  const payload: Omit<Post, 'id'> = {
    title: 'TypeScript mit Axios',
    body: 'Dies ist ein Testpost',
    userId: 1,
  };

  try {
    const response = await apiClient.post('/posts/add', payload);
    console.log('Erstellter Post', response.data);
  } catch (error) {
    console.log('Fehler beim Erstellen des Posts: ', error);
  }
}

createPost();

async function fetchWithRetry<T>(
  endpoint: string,
  retries = 3,
  delay = 1000
): Promise<T | null> {
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      return await fetchData<T>(endpoint);
    } catch (error) {
      if (attempt < retries) {
        await new Promise((resolve) => setTimeout(resolve, delay));
        delay *= 2;
      } else {
        console.error(
          'API endgültig fehlgeschlagen nach ',
          retries,
          'Versuchen: ',
          error
        );
        return null;
      }
    }
  }
  return null;
}

fetchWithRetry('/users/1?delay=5000');