import { Injectable } from '@angular/core';
import { NapAngularService } from 'nap-angular-sdk';
import {
  filterEvents,
  NAPEventCatalogue,
  NAPMessage
} from 'nap-typescript-sdk';
import { combineLatest, merge, Observable, Subject } from 'rxjs';
import { map, switchMap, tap } from 'rxjs/operators';
import { v4 as UUID } from 'uuid';
import { ConfigurationsService } from './configurations.service';

/**
 * Service to handle user session
 *
 * @export AuthService
 * @class AuthService
 */
@Injectable({
  providedIn: 'root',
})
export class AuthService {

  innerLogout = new Subject<undefined>();
  logOut$: Observable<boolean> = merge(
    this.innerLogout,
    this.napSDK.incoming$.pipe(
      filterEvents([NAPEventCatalogue.v1.SessionClose]),
    )).pipe(
      switchMap(() => this.logOutUrl$),
      tap(logOutUrl => {
        // Direct the window to the OIOSaml logout filter
        window.location.assign(logOutUrl);
        console.log('Will redirect:' + logOutUrl);
      }
      ),
      map(() => true)
    );

  private logOutUrl$: Observable<string> = combineLatest([
    this.configService.fetch(
      config => config.serverUrl
    ),
    this.configService.fetch(config => config.logOutEndpoint)
  ]).pipe(
    map(([serverUrl, logOutUrl]) => serverUrl + logOutUrl),
  )

  constructor(
    private napSDK: NapAngularService,
    private configService: ConfigurationsService
  ) {
  }

  /**
   * completes the current session and logs out the user
   */
  logout(): void {
    console.log('NapReferenceWeb Logging out');
    this.innerLogout.next(undefined);
    const napMsg: NAPMessage = {
      date: new Date().toISOString(),
      id: UUID(),
      event: { type: NAPEventCatalogue.v1.SessionClose },
    };
    this.napSDK.sendMessage(napMsg);

  }
}

  constructor(
    private napSDK: NapAngularService,
    private appointmentService: AppointmentService,
    private authService: AuthService
  ) {
    const napMsg: NAPMessage = {
      date: new Date().toISOString(),
      id: UUID(),
      event: {
        type: NAPEventCatalogue.v1.PatientOpen,
      },
    };
    this.napSDK.sendMessage(napMsg);
  }

  public currentPatient$: Observable<NAPPatientInfo | undefined> = this.napSDK.incoming$.pipe(
    filterEvent(NAPEventCatalogue.v1.PatientOpen),
    map(message => FHIRValueGetter.getPatientInfo(message))
  );

/**
 * Generetas Requests to get appoitnemnts for a given person and organization
 *
 * @export AppointmentService
 * @class AppointmentService
 */
@Injectable({
  providedIn: 'root'
})

export class AppointmentService {

  /**
   * The appointment endpoint
   *
   * @private
   * @memberof AppointmentService
   */
  private appointmentEndPoint$ = this.configurationService.fetch(
    config => config.appointmentsEndpoint
  );

  /**
   * The server url
   *
   * @private
   * @memberof AppointmentService
   */
  private serverUrl = this.configurationService.fetch(config => config.serverUrl);

  /**
   * A refresh indicator
   *
   * @private
   * @memberof AppointmentService
   */
  private serviceActivator = new BehaviorSubject(undefined);

  constructor(
    private http: HttpClient,
    private errorService: ErrorService,
    private configurationService: ConfigurationsService,
    private napSDK: NapAngularService
  ) {
  }

  /**
   * Make a HTTP GET to the serverurl/appointmentendpoint
   * @param patientIdentifier
   */
  public getAppointments(patientIdentifier: string | undefined): Observable<any[] | undefined> {
    return combineLatest(
      [
        this.serverUrl,
        this.appointmentEndPoint$,
        this.serviceActivator
      ]
    ).pipe(
      switchMap(([serverUrl, endpointPath, _]) => this.http.get<any[]>(serverUrl + endpointPath + '/' + patientIdentifier)),
      catchError(error => {
        this.errorService.postError(error);
        this.napSDK.sendMessage(NAPEventCatalogue.v1.MessageFactory.createSessionErrorMessage(UUID(), error.innerError?.message, error.errorMessage)); // indicate to the host that something went wrong
        return of(undefined);
      }),
    );
  }

  /**
   * Triggers a data update of the service
   */
  refresh(): void {
    this.serviceActivator.next(undefined);
  }
}

...
services:
 napreffacade:
    ...
    environment:
      # Set oiosaml.home + open debug socket
      - JAVA_OPTS=$JAVA_OPTS -Doiosaml.home=/pack/oiosaml -agentlib:jdwp=transport=dt_socket,address=8787,server=y,suspend=n

	...

 
@WebListener
public class SpringLoader implements ServletContextListener {
    protected static final String ANNOTATION_CONFIG_CONTEXT = "ANNOTATION_CONFIG_APPLICATION_CONTEXT";

    /**
     * Initialize standalone spring context. Registers the spring configuration and finally register it at the servlet context
     */
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        AnnotationConfigApplicationContext springContext = new AnnotationConfigApplicationContext();
        springContext.register(SpringContext.class);
        springContext.refresh();
        final ServletContext servletContext = servletContextEvent.getServletContext();
        servletContext.setAttribute(ANNOTATION_CONFIG_CONTEXT, springContext);
        ServletRegistration servletRegistration = servletContext.addServlet("SAMLDispatcherServlet", DispatcherServlet.class);
        servletRegistration.addMapping("/saml/*");
        FilterRegistration.Dynamic filterRegistration = servletContext.addFilter("LoginFilter", SPFilter.class);
        filterRegistration.addMappingForUrlPatterns(null, false, "/api/*");
        filterRegistration.addMappingForUrlPatterns(null, false, "/saml/*");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        Object ctx = servletContextEvent.getServletContext().getAttribute(ANNOTATION_CONFIG_CONTEXT);
        if(ctx instanceof AnnotationConfigApplicationContext) {
            ((AnnotationConfigApplicationContext)ctx).close();
        }
    }
}

@Provider
public class AuthFilter implements ContainerRequestFilter {
    static private final Logger log;
    public static final Response ACCESS_DENIED = Response.status(401).build();
    private static final String[][] XML_PATH_TO_SAML_ASSERTION = {
            {NameSpaces.WSA_1_0_SCHEMA, WSATags.metadata.getTagName()},
            {NameSpaces.LIBERTY_DISCOVERY_SCHEMA, LibertyDiscoveryTags.securityContext.getTagName()},
            {NameSpaces.LIBERTY_SECURITY_SCHEMA, LibertySecurityTags.token.getTagName()},
            {NameSpaces.SAML2ASSERTION_SCHEMA, SAMLTags.ASSERTION}
    };

    static {
        log = Logger.getLogger(AuthFilter.class);
    }

    @Override
    public void filter(ContainerRequestContext requestContext) {
        final RequestContext context = RequestContext.getContext();
        final UserAssertion userAssertion = UserAssertionHolder.get();
        context.setAssertion(userAssertion);
        context.setUserIdCard(getIdCardFromAssertion(userAssertion));
    }

    private UserIDCard getIdCardFromAssertion(UserAssertion ua) {
        UserAttribute attribute = ua.getAttribute(OIOSAMLAttributes.DISCOVERY_EPR);
        if (attribute == null) {
            if (log.isDebugEnabled()) log.debug("No embedded idcard in SAML assertion");
            return null;
        }

        if (!Attribute.URI_REFERENCE.equals(attribute.getFormat())) {
            if (log.isDebugEnabled()) log.debug("Attribute of name " + OIOSAMLAttributes.DISCOVERY_EPR +
                    " is not an embedded idcard - NameFormat mismatch (was + " + attribute.getFormat() +
                    ", expected " + Attribute.URI_REFERENCE);

            return null;
        }

        if (log.isDebugEnabled()) log.debug("Extracting idcard from SAML assertion");

        String attributeValue = attribute.getValue();
        InputSource inputSource = new InputSource(new StringReader(attributeValue));
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        documentBuilderFactory.setNamespaceAware(true);
        DocumentBuilder documentBuilder;
        try {
            documentBuilder = documentBuilderFactory.newDocumentBuilder();
            Document document = documentBuilder.parse(inputSource);

            Element idCardElm = getDescendant(document.getDocumentElement());

            return (UserIDCard) new IDCardModelBuilder().buildModel(idCardElm);

        } catch (ParserConfigurationException | SAXException | IOException e) {
            log.error("Error parsing embedded idcard", e);
        }

        return null;
    }

    private Element getDescendant(Element elm) {
        for (String[] qName : AuthFilter.XML_PATH_TO_SAML_ASSERTION) {
            NodeList nodeList = elm.getElementsByTagNameNS(qName[0], qName[1]);
            if (nodeList == null || nodeList.getLength() == 0) {
                log.error("Path element not found: {" + qName[0] + "}" + qName[1]);
                return null;
            }
            Node child = nodeList.item(0);
            if (!(child instanceof Element)) {
                log.error("Path component {" + qName[0] + "}" + qName[1] + " is not an element; node=" + child);
                return null;
            }
            elm = (Element) nodeList.item(0);
        }

        return elm;
    }
}