import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders, HttpResponse } from '@angular/common/http';
import { Observable, throwError } from 'rxjs';
import { catchError, map } from 'rxjs/operators';
import { environment } from 'src/environments/environment';

@Injectable({
  providedIn: 'root',
})
export class AuthService {
  isAuthenticated(): boolean {
    return !!sessionStorage.getItem('username');
  }
  private ApiVerifAuthUrl = `${environment.apiBaseUrl}/api/token/verify/`;

  private apiURL = `${environment.apiBaseUrl}/user-info/`;

  //private ApiTokAuthUrl = `${environment.apiBaseUrl}/api/token/`;

  private ApiRefAuthUrl = `${environment.apiBaseUrl}/api-token-refresh/`;
  // Options HTTP utilisées pour effectuer les appels API
  private httpOptions = {
    headers: new HttpHeaders({ 'Content-Type': 'application/json' }),
  };

  // Le jeton JWT réel
  public token: string | undefined;

  // La date d'expiration du jeton
  public token_expires: Date | undefined;

  // Le nom d'utilisateur de l'utilisateur connecté
  public username: string | undefined;

  // Messages d'erreur reçus lors de la tentative de connexion
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  public errors: any[] = [];

  constructor(private http: HttpClient) {}

  public verifyToken(
    token: string
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
  ): Observable<{ status: boolean; data?: any }> {
    const headers = new HttpHeaders({
      'Content-Type': 'application/json',
      'X-CSRFToken':
        'eiasfUdm3tAA1j8nJYoL3fqBR6uFk3dJ7XCffWJ7v3oAGBXHKW4rWXxL1FoRUnXZ',
    });

    const body = { token };

    return (
      this.http
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        .post<any>(this.ApiVerifAuthUrl, body, {
          headers,
          observe: 'response',
        })
        .pipe(
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          map((response: HttpResponse<any>) => {
            return { status: response.status === 200, data: response.body };
          }),
          catchError(error => {
            console.error('An error occurred:', error);
            return throwError({ status: false });
          })
        )
    );
  }
  public login(username: string, password: string): Observable<any> {
    const headers = new HttpHeaders({
      Accept: 'application/json',
      'Content-Type': 'application/json',
      'X-CSRFToken':
        '6EZeWkpQaDPitcgEckosv48y2bLvYlFbv2heOldXY9EbfeGnwLGBjd0uclhLqt0n',
      Authorization: 'Basic ' + btoa(`${username}:${password}`),
    });

    return this.http.get(this.apiURL, { headers, observe: 'response' }).pipe(
      map(response => {
        if (response.status === 200) {
          console.log('Connexion réussie');
          return { status: true, data: response.body };
        } else {
          console.error('Échec de la connexion :', response.statusText);
          return { status: false, error: response.statusText };
        }
      }),
      catchError(error => {
        console.error("Une erreur s'est produite lors de la requête :", error);
        return throwError({
          status: false,
          error: "Une erreur s'est produite lors de la requête.",
        });
      })
    );
  }

  // Rafraîchit le jeton JWT pour prolonger la session de l'utilisateur
  public refreshToken() {
    return (
      this.http
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        .post<any>(this.ApiRefAuthUrl, { token: this.token }, this.httpOptions)
        .subscribe(
          data => {
            data;
            console.log(data);
          },
          err => {
            this.errors = err.error;
          }
        )
    );
  }

  // Déconnexion de l'utilisateur
  public logout() {
    // sessionStorage.removeItem('username');

    console.log('deconnxion en cours.................')
  }

  // Met à jour les données utilisateur après une connexion réussie ou un rafraîchissement de jeton
  private updateData(token: string) {
    this.token = token;
    this.errors = [];

    // Décoder le jeton pour lire le nom d'utilisateur et le timestamp d'expiration
    const token_parts = token.split(/\./);
    const token_decoded = JSON.parse(atob(token_parts[1]));
    this.token_expires = new Date(token_decoded.exp * 1000);
    this.username = token_decoded.username;
  }
}