import { Injectable } from '@angular/core';
import { HttpClient, HttpParams, HttpErrorResponse } from '@angular/common/http';
import { Observable, throwError } from 'rxjs';
import { catchError, tap } from 'rxjs/operators';
import { AvisoDto, TvSettings } from './aviso.dto';  
import { AvisoTvTextSettingsDto } from './aviso-tv-settings.dto';  
import { environment } from '../../environments/environment';

 
export interface AvisoArrivalsResponse {
  avisos: AvisoDto[];
  totalCount: number;
}

@Injectable({
  providedIn: 'root'
})
export class AvisoService {

  private baseUrl = environment.baseUrl;

  constructor(private http: HttpClient) { }

  /**
   * Holt die Ankünfte (Arrivals) basierend auf den übergebenen Parametern.
   * @param standort Standort zur Filterung der Ankünfte.
   * @param seiten Gibt an, ob nur Seiten zurückgegeben werden sollen.
   * @param onlyOK Gibt an, ob nur gültige Ankünfte zurückgegeben werden sollen.
   * @returns Ein Observable von AvisoArrivalsResponse.
   */
  getArrivals(standort: string, onlyOK: boolean = false): Observable<AvisoArrivalsResponse> {
    let params = new HttpParams()
      .set('standort', standort)
      .set('seiten', 'True')
      .set('onlyOK', onlyOK.toString());

    return this.http.get<AvisoArrivalsResponse>(`${this.baseUrl}/Aviso/arrivals`, { params })
      .pipe(
        tap(data => console.log('AvisoService received arrivals data:', data)), // Logge die empfangenen Daten
        catchError(this.handleError)
      );
  }

  /**
   * Holt die Aviso TV Einstellungen basierend auf dem übergebenen Standort.
   * @param standort Standort zur Filterung der Einstellungen.
   * @returns Ein Observable von AvisoTvTextSettingsDto[].
   */
  getAvisoTvTextSettings(standort: string): Observable<AvisoTvTextSettingsDto[]> {
    return this.http.get<AvisoTvTextSettingsDto[]>(`${this.baseUrl}/AvisoTv/${standort}`)
      .pipe(
        tap(data => console.log('AvisoService received TV Text settings data:', data)),
        catchError(this.handleError)
      );
  } 

  getAvisoTvSettings(standortID: number): Observable<TvSettings[]> {
    return this.http.get<TvSettings[]>(`${this.baseUrl}/AvisoTvSettings/Standort/${standortID}`)
      .pipe(
        tap(data => console.log('AvisoService received TV settings data:', data)), // Logge die empfangenen Daten
        catchError(this.handleError)
      );
  }

  /**
   * Holt die bereitstehenden Avisos basierend auf dem übergebenen Standort.
   * @param standort Standort zur Filterung der bereitstehenden Avisos.
   * @returns Ein Observable von AvisoDto[].
   */
  getReadyAvisos(standort: string = ''): Observable<AvisoDto[]> {
    let params = new HttpParams().set('standort', standort);
    return this.http.get<AvisoDto[]>(`${this.baseUrl}/ready`, { params })
      .pipe(
        tap(data => console.log('AvisoService received ready avisos:', data)), // Logge die empfangenen Daten
        catchError(this.handleError)
      );
  }

  /**
   * Behandelt Fehler, die während HTTP-Anfragen auftreten.
   * @param error Das aufgetretene HttpErrorResponse-Objekt.
   * @returns Ein Observable, das einen Fehler auswirft.
   */
  private handleError(error: HttpErrorResponse) {
    let errorMessage = 'Unbekannter Fehler!';
    if (error.error instanceof ErrorEvent) {
      // Client-seitiger Fehler
      errorMessage = `Fehler: ${error.error.message}`;
    } else {
      // Server-seitiger Fehler
      errorMessage = `Server returned code: ${error.status}, error message is: ${error.message}`;
    }
    return throwError(errorMessage);
  }

  getStandortID(standort: string): Observable<{ standortID: number }> {
    return this.http.get<{ standortID: number }>(`${this.baseUrl}/AvisoTv/StandortID/${standort}`)
      .pipe(
        tap(data => console.log('AvisoService received StandortID:', data)),
        catchError(this.handleError)
      );
  }

}
