import {Injectable} from '@angular/core';
import {Observable, ReplaySubject, Subject} from 'rxjs';
import {LocalStorageService} from './local-storage.service';

@Injectable({
  providedIn: 'root'
})
export class PatientContextService {
  private currentCpr: string | undefined;
  private currentEpisodeOfCare: string | undefined;
  private currentXBreakTheGlassReason: string | undefined;
  private currentHasPrivatelyMarkedData: boolean | undefined;
  private currentPatientExists: boolean | undefined;


  private readonly innerCpr: Subject<string | undefined> = new Subject();
  private readonly innerEpisodeOfCare: ReplaySubject<string | undefined> = new ReplaySubject();
  private readonly innerXBreakTheGlassReason: Subject<string | undefined> = new Subject();
  private readonly innerHasPrivatelyMarkedData: Subject<boolean | undefined> = new Subject();
  private readonly innerPatientExists: Subject<boolean | undefined> = new Subject();

  constructor(private localStorageService: LocalStorageService) {
  }

  public loadPatientContextFromLocalStorage(): void {
    const {cpr, xBreakTheGlassReason} = this.localStorageService.getPatientContext();
    if (cpr) {
      this.setCpr(cpr);
    }
    if (xBreakTheGlassReason) {
      this.setXBreakTheGlassReason(xBreakTheGlassReason);
    }
  }

  public setCpr(cpr?: string): void {
    if (this.currentCpr !== cpr) {
      this.currentCpr = cpr;
      this.localStorageService.setPatientContextCpr(cpr);
      this.innerCpr.next(cpr);

      // Clear patient context on new patient
      this.setEpisodeOfCare(undefined);
      this.setXBreakTheGlassReason(undefined);
      this.setHasPrivatelyMarkedData(undefined);
      this.setPatientExists(undefined);
    }
  }

  public setEpisodeOfCare(episodeOfCareIdentifier?: string): void {
    if (episodeOfCareIdentifier) {
      this.currentEpisodeOfCare = episodeOfCareIdentifier;
      this.innerEpisodeOfCare.next(episodeOfCareIdentifier); // publish every time it is set.
    }
  }

  public setXBreakTheGlassReason(xBreakTheGlassReason?: string): void {
    if (this.currentXBreakTheGlassReason !== xBreakTheGlassReason) {
      this.currentXBreakTheGlassReason = xBreakTheGlassReason;
      this.localStorageService.setPatientContextXBreakTheGlassReason(xBreakTheGlassReason);
      this.innerXBreakTheGlassReason.next(xBreakTheGlassReason);
    }
  }

  public setHasPrivatelyMarkedData(value?: boolean): void {
    if (this.currentHasPrivatelyMarkedData !== value) {
      this.currentHasPrivatelyMarkedData = value;
      this.innerHasPrivatelyMarkedData.next(value);
    }
  }

  public setPatientExists(exists?: boolean): void {
    if (this.currentPatientExists !== exists) {
      this.currentPatientExists = exists;
      this.innerPatientExists.next(exists);
    }
  }

  public getCurrentCpr(): string | undefined {
    return this.currentCpr;
  }

  public getCurrentEpisodeOfCare(): string | undefined {
    return this.currentEpisodeOfCare;
  }

  public getCurrentXBreakTheGlassReason(): string | undefined {
    return this.currentXBreakTheGlassReason;
  }

  public getCurrentHasPrivatelyMarkedData(): boolean | undefined {
    return this.currentHasPrivatelyMarkedData;
  }

  public getCurrentPatientExists(): boolean | undefined {
    return this.currentPatientExists;
  }

  get cpr$(): Observable<string | undefined> {
    return this.innerCpr;
  }

  get episodeOfCare$(): Observable<string | undefined> {
    return this.innerEpisodeOfCare;
  }

  get xBreakTheGlassReason$(): Observable<string | undefined> {
    return this.innerXBreakTheGlassReason;
  }

  get hasPrivatelyMarkedData$(): Observable<boolean | undefined> {
    return this.innerHasPrivatelyMarkedData;
  }

  get patientExists$(): Observable<boolean | undefined> {
    return this.innerPatientExists;
  }
}