import { HttpErrorResponse } from '@angular/common/http';
import { CustomHttpError } from '../models/custom-http-error.model';
import { RawHttpErrorResponse, ErrorCodes } from '../models';
import { isArray } from 'lodash-es';
import { getMatFormFieldPlaceholderConflictError } from '@angular/material/form-field';
import { NumberValueAccessor } from '@angular/forms';

export class MwHttpErrorParser {
  private readonly ErrorStringMap: { [key: string]: ErrorCodes } = {
    ['invalid_grant']: ErrorCodes.InvalidGrant,
  };
  private readonly ResponseStatusCodeMap: { [key: number]: ErrorCodes } = {
    400: ErrorCodes.BadRequest,
    404: ErrorCodes.NotFound,
    401: ErrorCodes.Unauthorized,
    500: ErrorCodes.ServerError,
  };

  parse(
    data: HttpErrorResponse | CustomHttpError | Error
  ): RawHttpErrorResponse {
    let result: RawHttpErrorResponse = new RawHttpErrorResponse(data);

    if (data instanceof CustomHttpError) {
      result = this.parseCustomHttpError(data);
    } else if (data instanceof Error) {
      result = this.parseError(data);
    } else if (data instanceof HttpErrorResponse) {
      result = this.parseHttpErrorResponse(data);
    }

    return result;
  }

  private parseCustomHttpError(data: CustomHttpError): RawHttpErrorResponse {
    const result: RawHttpErrorResponse = new RawHttpErrorResponse(data);
    const generalException = data;
    result.setError(generalException.errorCode, generalException.message);
    return result;
  }

  private parseError(data: Error): RawHttpErrorResponse {
    const result: RawHttpErrorResponse = new RawHttpErrorResponse(data);
    result.isException = true;
    result.setError(ErrorCodes.Unknown, `${data.name}: ${data.message}`);
    console.error(`${data.name}: ${data.message} \r\n ${data.stack}`);

    return result;
  }

  private parseHttpErrorResponse(
    data: HttpErrorResponse
  ): RawHttpErrorResponse {
    const errorCode = this.toErrorCode(data);
    const result = new RawHttpErrorResponse(data);
    const errors = data.error?.errors;
    result.isException = !!data.error?.exceptionTag;

    if (errors && !isArray(errors)) {
      Object.keys(errors).forEach((key) => {
        result.setError(errorCode, `${key}: ${errors[key]}`);
      });
    } else if (isArray(errors)) {
      (
        errors as Array<{
          errorCode: ErrorCodes;
          message: string;
        }>
      ).forEach((errorItem) =>
        result.setError(errorItem.errorCode, errorItem.message)
      );
    } else {
      const defaultMessage = this.geHttpErrorResponseErrorMessage(data);
      const rawErrorItem = result.setError(errorCode, defaultMessage);
      rawErrorItem.details = this.geHttpErrorResponseErrorMessageDetails(data);
    }

    return result;
  }

  private geHttpErrorResponseErrorMessage(data: HttpErrorResponse): string {
    if (data.status === 404) {
      return `${data.statusText} ${data.url}`;
    }

    const mainErrorField = data?.error;

    return (
      mainErrorField?.error_description ||
      mainErrorField?.message ||
      (mainErrorField?.exceptionTag &&
        `exceptionTag: ${data.error.exceptionTag}`) ||
      (typeof mainErrorField === 'string' && mainErrorField) ||
      mainErrorField?.title ||
      (mainErrorField?.errors && mainErrorField?.errors[0]?.message) ||
      data.message
    );
  }

  private geHttpErrorResponseErrorMessageDetails(
    data: HttpErrorResponse
  ): string {
    const mainErrorField = data?.error;

    return (
      mainErrorField?.messageDetail ||
      mainErrorField?.errors ||
      mainErrorField?.detail ||
      mainErrorField
    );
  }

  private toErrorCode(data: HttpErrorResponse): ErrorCodes {
    const errorCode =
      data.error && data.error.errors && data.error.errors[0]?.errorCode;
    const errorString = data.error && data.error.error;
    return (
      errorCode ||
      this.ErrorStringMap[errorString] ||
      this.ResponseStatusCodeMap[data.status] ||
      ErrorCodes.Unknown
    );
  }
}