import { HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { ErrorType } from '@dafa-enums/error-type.enum';
import { environment } from '@dafa-environment';
import {
  Employee,
  EmployeeApiResponse,
  mapEmployeeReponseToEmployee,
  mapEmployeeToEmployeeApiRequestData,
  PegaEmployeeApiPostResponse,
} from '@dafa-models/employee.model';
import { SortBy } from '@dafa-models/sort-by.model';
import { sort } from '@dafa-utils/sort.util';
import { BehaviorSubject, combineLatest, Observable, throwError } from 'rxjs';
import { catchError, map } from 'rxjs/operators';

function filterEmployees(employees: Employee[], searchFilter: string): Employee[] {
  return employees.filter(person => person.fullName.toLowerCase().includes(searchFilter.toLowerCase()));
}

const API_HEADERS = { headers: environment.api.headers };
@Injectable({
  providedIn: 'root',
})
export class EmployeeService {
  private _employeeApiUrl = `${environment.api.url}/employee`;
  private _employeesRawData: Observable<EmployeeApiResponse[]> = this.httpClient.get<EmployeeApiResponse[]>(
    this._employeeApiUrl,
    API_HEADERS
  );
  private _allEmployees$: Observable<Employee[]> = this._employeesRawData.pipe(
    map(results => results.map(result => mapEmployeeReponseToEmployee(result)))
  );

  private _employeesSortBy$ = new BehaviorSubject<SortBy | null>({ key: 'fullName', reverse: false });
  public employeesSortBy$: Observable<SortBy> = this._employeesSortBy$.asObservable();
  private _searchFilter$ = new BehaviorSubject<string>('');
  public searchFilter$: Observable<string> = this._searchFilter$.asObservable();

  private _filteredEmployees$: Observable<Employee[]> = combineLatest([this._allEmployees$, this._searchFilter$]).pipe(
    map(([employees, searchFilter]) => filterEmployees(employees, searchFilter))
  );

  public resultCount$: Observable<number> = this._employeesRawData.pipe(map(results => results.length)); // TODO: need META
  public filteredEmployees$: Observable<Employee[]> = combineLatest([
    this._filteredEmployees$,
    this._employeesSortBy$,
  ]).pipe(
    map(([employees, sortBy]) => {
      return sortBy ? sort(employees, sortBy) : employees;
    })
  );

  constructor(private httpClient: HttpClient) {}

  public getDetailedEmployeeData(id: string): Observable<Employee> {
    return this.httpClient
      .get<EmployeeApiResponse>(`${this._employeeApiUrl}/${id}`, { ...API_HEADERS })
      .pipe(map(result => mapEmployeeReponseToEmployee(result)));
  }

  public setSearchFilter(value: string) {
    this._searchFilter$.next(value);
  }

  public setEmployeesSortKey(key: keyof Employee) {
    const currentSortBy = this._employeesSortBy$.getValue();
    const reverse = currentSortBy?.key === key ? !currentSortBy.reverse : false;
    this._employeesSortBy$.next({ key, reverse });
  }

  public postNewEmployee(employeeData: Employee): Observable<string> {
    console.log(employeeData);
    return;
    return this.httpClient
      .post<PegaEmployeeApiPostResponse>(
        this._employeeApiUrl,
        mapEmployeeToEmployeeApiRequestData(employeeData),
        API_HEADERS
      )
      .pipe(
        map(data => {
          if (data.pyHasError === 'true') {
            throw new Error(data.pyErrorMessage);
          }
          return data.pyUserIdentifier;
        }),
        catchError(error => throwError({ message: error, type: ErrorType.API }))
      );
  }
}