import { HttpClient, HttpEventType, HttpHeaders, HttpRequest, HttpResponse } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { FileStatus, FileUploadEvent } from '@core/typings/file.typing';
import { environment } from '@environment';
import { IHttpRestService } from '@yourcause/common/http';
import { filter, map, mergeMap, Observable, of } from 'rxjs';
import { VirusScanService } from './virus-scan.service';

@Injectable({ providedIn: 'root' })
export class HttpRestService implements IHttpRestService {

  constructor (
    private virusScanService: VirusScanService,
    private http: HttpClient
  ) { }

  get <T = any> (url: string, headers?: any): Promise <T> {
    return this.makeRequest(url, 'get', null, headers);
  }

  post <T = any, B = any> (url: string, data: B, headers?: any): Promise<T> {
    return this.makeRequest(url, 'post', data, headers);
  }

  /**
   * Returns an observable of `FileEvent`s indicating upload progress
   *
   * @param url URL to ultimately upload the file
   * @param fileToUpload File being uploaded
   * @param paramName Param on the post body for the file
   * @param fileName Name of the file (if uploading a Blob)
   */
  postFileWithProgress<T = any> (
    url: string,
    fileToUpload: File,
    paramName = 'file',
    fileName?: string
  ): Observable<FileUploadEvent<T>> {
    const { request, formData, file } = this.setupFormData(fileToUpload, fileName, paramName, url);

    if (environment.virusScanEnabled) {

      return this.virusScanService.scanFileForVirusesNew(file).pipe(
        mergeMap<FileUploadEvent<string>, Observable<any>>((scanValue) => {
          if (scanValue.status === FileStatus.COMPLETE_VIRUS_SCAN) {
            formData.append('ClamAVToken', scanValue.result);

            return this.performPostFileWithProgress<T>(request);
          }

          return of(scanValue);
        }))
        .pipe(filter(value => value !== null));
      }

      return this.performPostFileWithProgress<T>(request);
  }

  private performPostFileWithProgress<T = any> (request: HttpRequest<FormData>): Observable<FileUploadEvent<T>> {
    return this.http.request<string>(request)
      .pipe(map(event => {
        let returnValue: FileUploadEvent<T> | null = null;
        switch (event.type) {
          case HttpEventType.UploadProgress:
            returnValue = {
              progress: event.loaded / event.total,
              status: FileStatus.UPLOAD_API
            };
            break;
          case HttpEventType.Response:
            const response: T = JSON.parse((<HttpResponse<string>>event).body);
            returnValue = {
              status: FileStatus.COMPLETE,
              result: response
            };

            break;
        }

        return returnValue;
      })).pipe(filter(value => value !== null));
  }

  async postFile<T = any> (
    url: string,
    fileToUpload: File|Blob|string,
    paramName = 'file',
    fileName?: string
  ) {
    const { request, formData, file } = this.setupFormData(fileToUpload, fileName, paramName, url);

    if (environment.virusScanEnabled) {
      const virusResponse = await this.virusScanService.scanFileForViruses(file);
      formData.append('ClamAVToken', virusResponse.scanToken);
    }

    return this.http.request(request).pipe(
      filter(event => event instanceof HttpResponse),
      map(event => (<HttpResponse<T>>event).body))
      .toPromise();
  }

  private setupFormData (
    file: string | File | Blob,
    fileName: string,
    paramName: string,
    url: string,
    responseType: 'text'|'arraybuffer'|'blob'|'json' = 'json'
  ) {
    const formData = new FormData();
    if (typeof file === 'string') {
      file = new File([new Blob([file])], fileName || 'upload');
    }
    if (!(file instanceof File) && fileName) {
      formData.append(paramName, file, fileName);
    } else {
      formData.append(paramName, file);
    }
    const request = new HttpRequest('POST', url, formData, {
      reportProgress: true,
      headers: new HttpHeaders({ 'ngsw-bypass': 'true' }),
      responseType
    });

    return { formData, request, file };
  }

  put <T = any> (url: string, data: any, headers?: any): Promise<T> {
    return this.makeRequest(url, 'put', data, headers);
  }

  delete <T = any> (url: string, headers?: any): Promise<T> {
    return this.makeRequest(url, 'delete', null, headers);
  }

  putS3PublicRead<T = any> (url: string, file: any, contentType: string): Promise<T> {
    return this.putS3(url, file, contentType, true);
  }


  protected makeRequest <T, B> (
    url: string,
    method: 'get'|'post'|'put'|'delete',
    data: B,
    inputHeaders?: any
  ): Promise<T> {
    let observable: Observable<T>;
    switch (method) {
      case 'get':
        observable = this.http.get<T>(url, {
          headers: inputHeaders
        });
        break;
      case 'post':
        observable = this.http.post<T>(url, data, {
          headers: inputHeaders
        });
        break;
      case 'put':
        observable = this.http.put<T>(url, data, {
          headers: inputHeaders
        });
        break;
      case 'delete':
        observable = this.http.delete<T>(url, {
          headers: inputHeaders
        });
        break;
    }

    return observable
      .toPromise();
  }

  private putS3<T> (
    url: string,
    file: File,
    contentType: string,
    isPublicRead: boolean
  ): Promise<T> {
    return new Promise((resolve, reject) => {

      const xhr = new XMLHttpRequest();

      xhr.open('PUT', url);
      xhr.setRequestHeader('Content-Type', contentType);
      if (isPublicRead) {
        xhr.setRequestHeader('x-amz-acl', 'public-read');
      }
      xhr.onreadystatechange = () => {
        if (xhr.readyState === 4) {
          if (xhr.status === 200) {
            resolve(xhr.response);
          } else {
            reject(xhr.response);
          }
        }
      };
      xhr.send(file);
    });
  }
}