import { InitAuthProcessInterface } from './interfaces/init-auth-process.interface';
import {
  AUTH_REDIRECT_URI,
  AUTH_SCOPE,
  AWS_EBAC_PASSPORT_CLIENT_ID,
  DEFAULT_AUTH_SCOPE,
  DEFAULT_EBAC_PASSPORT_AUTH_URI,
  DEFAULT_EBAC_PASSPORT_DOMAIN_URI,
  DEFAULT_EBAC_PASSPORT_SIGNIN_URI,
  DEFAULT_EBAC_PASSPORT_WITH_AUTH_FORM,
  EBAC_PASSPORT_AUTH_URI,
  EBAC_PASSPORT_DOMAIN_URI,
  EBAC_PASSPORT_SIGNIN_URI,
  EBAC_PASSPORT_WITH_AUTH_FORM,
  IS_EBAC_PASSPORT_BACKEND,
} from '../../constants';
import { ConfigService } from '@nestjs/config';
import { SessionAuthInterface } from './session-auth.interface';
import { SessionPassportAuthInterface } from './interfaces/session-passport-auth.interface';
import { SessionAuthInitInterface } from './interfaces/session-auth-init.interface';
import { SessionManagerInterface } from '../session-manager/session-manager.interface';
import { SessionPassportInterface } from '../session-manager/interfaces/session-passport.interface';
import { MiddlewareInterface } from '../../interfaces/middleware.interface';
import { valueToBoolean } from '../../utils/value-to-boolean';

export class SessionAuth implements SessionAuthInterface {
  clientId: string;
  redirectUri: string;
  ebacPassportSigninUri: string;
  ebacPassportAuthUri: string;
  ebacPassportDomainUri: string;
  ebacPassportWithAuthForm = false;
  configService: ConfigService;
  sessionManager: SessionManagerInterface;

  constructor(params: SessionAuthInitInterface) {
    this.init(params);
  }

  init(params: SessionAuthInitInterface): void {
    this.configService = params.configService;
    this.sessionManager = params.sessionManager;
    this.clientId = this.getClientId();
    this.redirectUri = this.getRedirectUri();
    this.ebacPassportSigninUri = this.getEbacPassportSigninUri();
    this.ebacPassportAuthUri = this.getEbacPassportAuthUri();
    this.ebacPassportDomainUri = this.getEbacPassportDomainUri();
    this.ebacPassportWithAuthForm = this.getEbacPassportWithAuthFrom();
  }

  initAuthProcessWithRedirect(params: InitAuthProcessInterface): void {
    console.log({ initAuthProcessWithRedirect: 'initAuthProcessWithRedirect' });
    if (this.isEbacPassportBackend()) {
      this.redirectToSignin(params);
      return;
    }

    this.initAuthProcess(params);
    const auth: SessionPassportAuthInterface = this.getSessionAuth(params);

    const authUriWithQueryParams: string =
      this.generateAuthUriWithQueryParams(auth);

    console.log({ authUriWithQueryParams });
    params.res.send(`redirectUri:${authUriWithQueryParams}`);
    params.res.end();
    return;
  }

  initAuthProcess(params: InitAuthProcessInterface): void {
    console.log({ initAuthProcess: 'initAuthProcess' });
    const scope: string = this.getScope(params);
    const state: string = params?.state;
    const auth: SessionPassportAuthInterface = {
      clientId: this.clientId,
      redirectUri: this.redirectUri,
      scope,
      state,
    };

    const passport: SessionPassportInterface =
      this.sessionManager.getSessionPassport(params);
    passport.auth = auth;
  }

  getSessionAuth(params: MiddlewareInterface): SessionPassportAuthInterface {
    const passport: SessionPassportInterface =
      this.sessionManager.getSessionPassport(params);
    const auth: SessionPassportAuthInterface = passport.auth;
    return auth;
  }

  redirectToSignin(params: MiddlewareInterface): void {
    const signinUri: string = this.generateSigninUri();
    params.res.send(`redirectUri:${signinUri}`);
  }

  private generateAuthUriWithQueryParams(
    auth: SessionPassportAuthInterface,
  ): string {
    let uri = this.generateAuthUri();

    uri += `?response_type=code`;

    if (auth.clientId) {
      uri += `&client_id=${auth.clientId}`;
    }
    if (auth.redirectUri) {
      uri += `&redirect_uri=${auth.redirectUri}`;
    }
    if (auth.scope) {
      uri += `&scope=${auth.scope}`;
    }
    if (auth.state) {
      uri += `&state=${auth.state}`;
    }

    return uri;
  }

  private generateAuthUri(): string {
    if (this.ebacPassportWithAuthForm) {
      const uri = `${this.ebacPassportDomainUri}/${this.ebacPassportAuthUri}`;
      return uri;
    } else {
      return this.generateSigninUri();
    }
  }

  private generateSigninUri(): string {
    const uri = `${this.ebacPassportDomainUri}/${this.ebacPassportSigninUri}`;
    return uri;
  }

  private getClientId(): string {
    const clientId: string = this.configService.get<string>(
      AWS_EBAC_PASSPORT_CLIENT_ID,
    );

    if (!clientId) {
      throw new Error('EBAC passport client id not set');
    }
    return clientId;
  }

  private getRedirectUri(): string {
    const redirectUri: string =
      this.configService.get<string>(AUTH_REDIRECT_URI);

    if (!redirectUri) {
      throw new Error('Auth redirect uri not set');
    }
    return redirectUri;
  }

  private getEbacPassportSigninUri(): string {
    const signinUri: string =
      this.configService.get<string>(EBAC_PASSPORT_SIGNIN_URI) ||
      DEFAULT_EBAC_PASSPORT_SIGNIN_URI;
    return signinUri;
  }

  private getEbacPassportAuthUri(): string {
    const authUri: string =
      this.configService.get<string>(EBAC_PASSPORT_AUTH_URI) ||
      DEFAULT_EBAC_PASSPORT_AUTH_URI;
    return authUri;
  }

  private getEbacPassportDomainUri(): string {
    const domainUri: string =
      this.configService.get<string>(EBAC_PASSPORT_DOMAIN_URI) ||
      DEFAULT_EBAC_PASSPORT_DOMAIN_URI;
    return domainUri;
  }

  private getScope(params: InitAuthProcessInterface): string {
    const scope: string =
      params.scope ||
      this.configService.get<string>(AUTH_SCOPE) ||
      DEFAULT_AUTH_SCOPE;
    return scope;
  }

  private getEbacPassportWithAuthFrom(): boolean {
    const withAuthForm = Boolean(
      this.configService.get<boolean>(EBAC_PASSPORT_WITH_AUTH_FORM) ||
        DEFAULT_EBAC_PASSPORT_WITH_AUTH_FORM,
    );
    return withAuthForm;
  }

  private isEbacPassportBackend(): boolean {
    const isEbacPassportBackend: boolean =
      valueToBoolean(
        this.configService.get<boolean>(IS_EBAC_PASSPORT_BACKEND),
      ) || false;
    return isEbacPassportBackend;
  }
}