import { NgxLoggerService } from '@allianz/ngx-logger';
import { inject, Injectable, Injector, runInInjectionContext } from '@angular/core';
import { Observable, Subject } from 'rxjs';
import { ConditionEvaluator, CONDITIONS_EVALUATORS } from './condition-evaluator.model';
import { PfeConditionsNormalizeUtils } from './conditions-normalizer.utils';
import { ConditionEvaluatorFunction, Conditions, PfeBaseCondition } from './conditions.model';
import { PfeConditionsService } from './conditions.service';

@Injectable()
export class PfeConditionsServiceImpl implements PfeConditionsService {
  readonly injector = inject(Injector);
  readonly logger = inject(NgxLoggerService, { optional: true });

  private _conditionExecuted$ = new Subject<PfeBaseCondition>();
  // eslint-disable-next-line @typescript-eslint/member-ordering
  public conditionExecuted$: Observable<PfeBaseCondition> = this._conditionExecuted$.asObservable();

  private conditionEvaluators: Map<string, ConditionEvaluatorFunction> = new Map<string, ConditionEvaluatorFunction>();

  public evaluateConditions(conditions: Conditions, state?: unknown): boolean {
    // Normalize the possible conditions until the old conditions are deprecate.
    const normalizedConditions: PfeBaseCondition[] = PfeConditionsNormalizeUtils.normalizeConditions(conditions);
    // If no conditions provided we return "false" by default
    if (!normalizedConditions.length) {
      this.logger?.warn('"evaluateConditions" called without conditions, returning false. Please check the configuration');
      return false;
    }
    return normalizedConditions.every((condition) => this.evaluateCondition(condition, state));
  }

  public evaluateCondition(condition: PfeBaseCondition, state?: unknown): boolean {
    try {
      const conditionEvaluator = this.getConditionEvaluator(condition.type);
      const result = conditionEvaluator(condition, state);
      this._conditionExecuted$.next(condition);
      return result;
    } catch (error: unknown) {
      this.logger?.error((error as Error)?.message || (error as string));
      return false;
    }
  }

  /**
   * Get a condition evaluator from the condition evaluator function
   * @param type The type that identifies the condition
   */
  private getConditionEvaluator(type: string): ConditionEvaluatorFunction {
    this.registerConditions();
    const evaluator = this.conditionEvaluators.get(type);

    if (!evaluator) {
      throw new RangeError(`Condition with "${type}" is not in the "CONDITIONS_EVALUATORS" token`);
    }

    return evaluator;
  }

  private registerConditions() {
    if (!this.conditionEvaluators.size) {
      const conditionEvaluators: ConditionEvaluator[] = runInInjectionContext(this.injector, () => inject(CONDITIONS_EVALUATORS));
      conditionEvaluators.forEach((evaluator) => this.conditionEvaluators.set(evaluator.type, evaluator.evaluator));

      const conditionEvaluatorsHasDuplicateTypes: boolean = this.conditionEvaluators.size !== conditionEvaluators.length;

      if (conditionEvaluatorsHasDuplicateTypes) {
        throw new RangeError('The provided "CONDITIONS_EVALUATORS" contains duplicated values.');
      }
    }
  }
}