import {catchError, mergeMap, Observable, retryWhen, tap, timer} from "rxjs";
import {HttpClient, HttpErrorResponse} from "@angular/common/http";
import {NotifyColor, OpenNotifyService} from "@service/open-notify.service";
import {environment} from "@environment";
import {Router} from "@angular/router";
import {Injectable} from "@angular/core";
import {RequestBuilder, RequestData, SetRequestBuilderAfterBuild} from "@api/RequestBuilder";

export function retryWithInterval<T>(): (source: Observable<T>) => Observable<T> {
  return (source: Observable<T>) =>
    source.pipe(
      retryWhen((errors: Observable<any>) =>
        errors.pipe(
          mergeMap((error, index) => {
            if (index < (environment.maxRetry < 0 ? Infinity : environment.maxRetry - 1) && !error.status.toString().startsWith('4') && !error.status.toString().startsWith('5')) {
              console.log(`Retrying after ${environment.retryDelay}ms...`);
              return timer(environment.retryDelay);
            } else {
              if (error.status.toString().startsWith('4'))
                console.error(`Server returned a client code error`);
              else
                console.error(`Exceeded maximum retries (${environment.maxRetry})`);

              throw error;
            }
          })
        )
      )
    );
}

export enum AvailableVersion {
  v1
}

@Injectable()
export default abstract class ApiService implements SetRequestBuilderAfterBuild {
  constructor(private http: HttpClient, private notify: OpenNotifyService, private router: Router) {
  }

  private apiUrl = environment.apiUrl;
  protected abstract basePath: string;
  protected abstract version: AvailableVersion;
  private request: RequestData = RequestBuilder.getStandardRequestData();

  public setRequestBuilder(request: RequestData): void {
    this.request = request;
  }

  private static addQuery(endpoint: string, queryParams?: Record<string, string | number | boolean | Array<any> | null> | null): string {
    const url = new URL(endpoint);

    if (queryParams) {
      Object.keys(queryParams).forEach(key => {
        const value = queryParams[key];
        if (value !== null && value !== undefined) {
          if (typeof (value) === typeof (Array)) {
            (value as Array<any>).forEach(x => url.searchParams.append(key, x.toString()));
          } else
            url.searchParams.append(key, value.toString());
        }
      });
    }

    return url.href;
  }

  private static combineUrls(...parts: string[]): string {
    return parts.map(part => part.replace(/(^\/+|\/+$)/g, '')).join('/');
  }

  protected get combinedUrl() {
    return ApiService.addQuery(ApiService.combineUrls(this.apiUrl, AvailableVersion[this.version], this.basePath, this.request.endpoint), this.request.queryParams)
  }

  private makeHttpRequest<Type>(method: 'get' | 'post' | 'delete' | 'put'): Observable<Type> {
    const doneEndpoint = this.combinedUrl;

    return this.tokenRefreshService.getTokenRefreshing$().pipe(
      filter(refreshing => !refreshing),
      take(1),
      switchMap(_ => {
        return this.http.request<Type>(method, doneEndpoint, {
          withCredentials: this.request.withCredentials,
          headers: this.request.httpHeaders,
          body: this.request.data
        }).pipe(
          tap(_ => this.request = RequestBuilder.getStandardRequestData()),
          retryWithInterval<Type>(),
          catchError(error => {
            if (!this.request.silenceMode)
              this.handleError(error);

            this.request = RequestBuilder.getStandardRequestData();
            throw error;
          })
        );
      })
    );
  }

  public createRequestBuilder() {
    this.request = RequestBuilder.getStandardRequestData();
    return new RequestBuilder(this);
  }

  public get<Type>(endpoint: string = ''): Observable<Type> {
    if (endpoint)
      this.request.endpoint = endpoint;
    return this.makeHttpRequest<Type>('get');
  }

  public post<Type>(endpoint: string = ''): Observable<Type> {
    if (endpoint)
      this.request.endpoint = endpoint;
    return this.makeHttpRequest<Type>('post');
  }

  public put<Type>(endpoint: string = ''): Observable<Type> {
    if (endpoint)
      this.request.endpoint = endpoint;
    return this.makeHttpRequest<Type>('put');
  }

  public delete<Type>(endpoint: string = ''): Observable<Type> {
    if (endpoint)
      this.request.endpoint = endpoint;
    return this.makeHttpRequest<Type>('delete');
  }

  private handleError(error: HttpErrorResponse): void {
    // todo: change to Retry-After condition
    if (error.error.toString().includes("setup")) {
      this.router.navigate(['/setup/']).then();
      return;
    }

    let message: string;
    if (error.error instanceof ErrorEvent) {
      message = `Произошла ошибка: ${error.error.message}`;
    } else {
      switch (error.status) {
        case 0:
          message = 'Неизвестная ошибка. Пожалуйста, попробуйте позже.';
          break;
        case 400:
          message = 'Ошибка запроса. Пожалуйста, проверьте отправленные данные.';
          break;
        case 401:
          message = 'Ошибка авторизации. Пожалуйста, выполните вход с правильными учетными данными.';
          break;
        case 403:
          message = 'Отказано в доступе. У вас нет разрешения на выполнение этого действия.';
          break;
        case 404:
          message = 'Запрашиваемый ресурс не найден.';
          break;
        case 500:
          message = 'Внутренняя ошибка сервера. Пожалуйста, попробуйте позже.';
          break;
        case 503:
          message = 'Сервер на обслуживании. Пожалуйста, попробуйте позже.';
          break;
        default:
          message = `Сервер вернул код ошибки: ${error.status}`;
          break;
      }
      if (error.error?.Error) {
        message += ` ${error.error.Error}`;
      }
    }
    this.notify.open(message, NotifyColor.Danger);
  }
}