// import { HttpInterceptorFn } from '@angular/common/http';
// import { Injectable } from '@angular/core';
// import {
//   HttpRequest,
//   HttpHandler,
//   HttpEvent,
//   HttpInterceptor,
//   HttpErrorResponse,
//   HTTP_INTERCEPTORS
// } from '@angular/common/http';
// import { catchError, Observable, switchMap, throwError } from 'rxjs';
// import { EventBusService } from '../services/event-bus.service';
// import { StorageService } from '../services/storage.service';

// import { Eventdata } from '../classes/eventdata';
// import { AuthService } from '../services/auth.service';
// import { CookieService } from 'ngx-cookie-service';

// //https://stackoverflow.com/questions/77840978/how-to-use-functional-interceptor-for-refreshing-token-in-angular-17
// export const autInterceptor: HttpInterceptorFn = (req, next) => {
//     const sessionStorageService = inject(SessionStorageService);
//   const { accessToken } = sessionStorageService.getSession(); // will return { accessToken: 'myAccessToken', refreshToken: 'myRefreshToken'}
//   if (accessToken) {
//     const clonedRequest = request.clone({
//        headers: req.headers.set('Authorization', `Bearer ${accessToken}`),
//     });
//     return next(clonedRequest);
//   } else {
//     return(request);
//   }
// };

// export const unauthErrorInterceptor: HttpInterceptorFn = (req: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>> => {
//   const tokenService = inject(TokenService);
//   const authService = inject(AuthService);
//   const sessionStorageService = inject(SessionStorageService);
  
//   return next(req).pipe(
//     catchError((error: HttpErrorResponse) => {
//       if (error instanceof HttpErrorResponse &&
//         !(req.url.includes('auth/login') || req.url.includes('auth/refresh')) && // <- this will avoid an infinite loop when the accessToken expires.
//         error.status === 401) {
//         const { refreshToken } = sessionStorageService.getSession();
//         if (refreshToken) {
//           return tokenService.refreshToken().pipe(
//             switchMap((refreshResult) => {
//               // assuming that tokenService.refreshToken() will return { accessToken: 'myNewAccessToken', refreshToken: 'myNewRefreshToken'}
//               sessionStorageService.saveSession(refreshResult);
//               return next(req.clone({
//                 headers: req.headers.set('Authorization', `Bearer ${refreshResult.accessToken}`),
//               }));
//             }),
//             catchError((error) => {
//               console.log('error')
//               if (error.status == '403' || error.status === '401') {
//                 authService.logout();
//               }
//               return throwError(() => error);
//             })
//           );
//         }
//       }
//       authService.logOut();
//       return throwError(() => new Error('Unauthorized Exception'));
//     })
//   );
// };




import { HttpInterceptorFn, HttpHandlerFn } from '@angular/common/http';
import { inject } from '@angular/core';
import { catchError, finalize, Observable, switchMap, throwError } from 'rxjs';
import { StorageService } from '../service/storage.service';
import { LoaderService } from 'src/app/core/services/loader.service';
import { AuthService } from '../service/auth.service';

/**
 * Adds access token to every request (if present)
 */
export const authInterceptor: HttpInterceptorFn = (req, next: HttpHandlerFn) => {
  const storage = inject(StorageService);
  // const loader = inject(LoaderService);

  // loader.show();

  const user = storage.getUser();
  const token = user?.token || user?.accessToken;

  if (token) {
    req = req.clone({
      setHeaders: {
        Authorization: `Bearer ${token}`
      }
    });
  }

  return next(req).pipe(
    // finalize(() => loader.hide())
  );
};

/**
 * Handles 401 and logs out if token invalid
 */
export const unauthErrorInterceptor: HttpInterceptorFn = (req, HttpHandlerFn) => {
  const auth = inject(AuthService);
  const loader = inject(LoaderService);

  // loader.show();

  return HttpHandlerFn(req).pipe(
    catchError(err => {
      if (err.status === 401 || err.status === 403) {
        auth.logout();
      }
      return throwError(() => err);
    }),
    finalize(() => loader.hide())
  );
};