import {
  ConditionAdvanced,
  ExpressionCondition,
  JSON_PATH_REGEX,
  OPERATORS,
  PFE_AND,
  PFE_EXPRESSION,
  PFE_OR,
  PageId,
  PageNavigationConfiguration,
  PfeConditionsNormalizeUtils,
  PfeConditionsService,
  PfeConfigurationService,
  PfeNavigationService,
  PfeRulesEvaluator,
  PfeStateService,
  PfeUserInputState,
  PfeUtilService,
} from '@allianz/ngx-pfe';
import { AfterViewInit, ChangeDetectorRef, Component, Input, OnInit } from '@angular/core';
import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
import jsonpath from 'jsonpath';
import { debounceTime, filter } from 'rxjs/operators';

const DEVTOOLSURLPARAM = 'devtools';
const EXAMPLE_EXPRESSION = '$.lastVisitedPage';
const EXAMPLE_EXPRESSION_CONDITION: ExpressionCondition[] = [
  { expression: '{$.pfeVisitedPages[:1]} === {$.lastVisitedPage}' },
  { value1Expression: '$.lastVisitedPage', operator: '==', value2Expression: '$.pfeVisitedPages[:1]' },
];
const EXAMPLE_CONDITION_ADVANCED: ConditionAdvanced = {
  operator: OPERATORS.AND,
  conditions: [
    { value1Expression: '$.lastVisitedPage', operator: '==', value2Expression: '$.pfeHistory[:1]' },
    { value1Expression: 5, operator: '==', value2Expression: 4 },
  ],
};

/**
 * @export
 */
@Component({
  selector: 'pfe-dev-tools',
  templateUrl: './pfe-dev-tools.component.html',
  styleUrls: ['./pfe-dev-tools.component.scss'],
})
export class DevToolsComponent implements OnInit, AfterViewInit {
  @Input() devToolsActive = false;
  @Input() beautifyJson = false;

  json: Record<string, unknown> | undefined;
  staleState: Record<string, unknown> | undefined;
  isBeautifyJson: boolean | undefined;
  jsonPathData: string | undefined;
  jsonPathExpression: string | undefined;
  jsonPathConditions: string | undefined;
  jsonPathResult: string | unknown;
  jsonQueryResult: string | undefined;
  jsonValueResult: string | undefined;
  conditionsResult: boolean | unknown;
  jsonStateData: string | undefined;
  conditionEvaluationLogs: string | undefined;
  pages: PageNavigationConfiguration[] | undefined;
  errorPageId: PageId | undefined;
  fGroup!: UntypedFormGroup;
  jsonPathError = false;
  conditionParseError = false;
  hideJsonPathMessage = false;
  hideConditionMessage = false;

  constructor(
    public pfeStateService: PfeStateService,
    private pfeConfigurationService: PfeConfigurationService,
    private pfeNavigationService: PfeNavigationService,
    private pfeUtilService: PfeUtilService,
    private cdRef: ChangeDetectorRef,
    private pfeConditionsService: PfeConditionsService
  ) {
    this.buildForm();
  }

  get exampleExpression() {
    return EXAMPLE_EXPRESSION;
  }

  get exampleExpressionCondition() {
    return JSON.stringify(EXAMPLE_EXPRESSION_CONDITION, null, 2);
  }

  get exampleConditionAdvanced() {
    return JSON.stringify(EXAMPLE_CONDITION_ADVANCED, null, 2);
  }

  ngOnInit(): void {
    const urlParam = this.pfeUtilService.getURLParam(DEVTOOLSURLPARAM);

    if (this.devToolsActive === true || (urlParam && urlParam === 'true')) {
      this.devToolsActive = true;

      this.pfeConfigurationService.getConfig().then((config) => {
        this.pages = config.navConfiguration.pages;
        this.errorPageId = config.navConfiguration.errorPageID;
      });
    }

    this.pfeStateService.pfeUserInputState$.pipe(debounceTime(500)).subscribe((value) => {
      this.json = value;
    });

    this.copyCurrentState();
  }

  ngAfterViewInit() {
    this.cdRef.detectChanges();
  }

  buildForm() {
    this.fGroup = new UntypedFormGroup({
      selectPage: new UntypedFormControl(),
    });

    this.fGroup.controls.selectPage.valueChanges.pipe(filter((value) => value !== null)).subscribe((value) => this.goToPage(value));
  }

  goToPage(pageID: string) {
    console.log(`Navigating directly to page: ${pageID}`);
    this.fGroup.controls.selectPage.reset(null);
    this.pfeNavigationService.navigate(pageID);
  }

  storeOnServer() {
    this.pfeStateService.storeState();
  }

  restoreFromServer() {
    this.pfeStateService.automaticallyRestoreState();
  }

  restoreFromInputField() {
    if (this.jsonStateData) {
      const state: PfeUserInputState = JSON.parse(this.jsonStateData);
      this.pfeStateService.restoreState(state);
    }
  }

  resetState() {
    this.pfeStateService.resetState();
  }

  copyCurrentState() {
    const state = this.pfeStateService.getFullState();
    this.jsonPathData = JSON.stringify(state);
    this.parseJsonPathData();
  }

  evaluateExpression() {
    this.jsonPathResult = '';
    this.jsonQueryResult = '';
    this.jsonValueResult = '';

    try {
      if (this.jsonPathData && this.jsonPathExpression) {
        const parsedJSON = JSON.parse(this.jsonPathData);
        const safeJsonPathExpression = this.jsonPathExpression.replace('[]$', '$');
        this.jsonPathResult = JSON.stringify(jsonpath.nodes(parsedJSON, safeJsonPathExpression), null, 2);

        this.jsonQueryResult = JSON.stringify(jsonpath.query(parsedJSON, safeJsonPathExpression), null, 2);

        this.jsonValueResult = JSON.stringify(PfeUtilService.getValueOrList(parsedJSON, this.jsonPathExpression, true), null, 2);
      }
    } catch (error) {
      this.jsonPathResult = error;
    }
  }

  evaluateCondition() {
    try {
      if (this.jsonPathData && this.jsonPathConditions) {
        const parsedJSON = JSON.parse(this.jsonPathData);
        this.conditionsResult = this.pfeConditionsService.evaluateConditions(JSON.parse(this.jsonPathConditions), parsedJSON);
        this.logConditionEvaluation(parsedJSON);
      }
    } catch (error) {
      this.conditionsResult = error;
    }
  }

  logConditionEvaluation(parsedJSON: Record<string, unknown>) {
    this.conditionEvaluationLogs = '';

    if (this.jsonPathData && this.jsonPathConditions) {
      const normalizedConditions = PfeConditionsNormalizeUtils.normalizeConditions(JSON.parse(this.jsonPathConditions));

      normalizedConditions.forEach((condition, index) => {
        // ConditionAdvanced
        if (condition.type === PFE_AND || condition.type === PFE_OR) {
          const conditionAdvanced = condition as unknown as ConditionAdvanced;
          this.conditionEvaluationLogs += `ConditionAdvanced ${condition.type}:\n\n`;
          this.conditionEvaluationLogs += '----------------------------------------------------------------\n\n';

          const evaluatedValues = conditionAdvanced.conditions.map((expressionCondition, conditionAdvancedIndex) => {
            const values = this.logConditionWithOperator(expressionCondition, parsedJSON, conditionAdvancedIndex);
            this.conditionEvaluationLogs += '----------------------------------------------------------------\n\n';
            return values;
          });
          const logicalOperator = condition.type === PFE_AND ? ' AND ' : ' OR ';
          const conditionsResult = this.pfeConditionsService.evaluateConditions(condition, parsedJSON);
          this.conditionEvaluationLogs += `${evaluatedValues.join(logicalOperator)} => ${conditionsResult} \n\n`;
        }

        if (condition.type === PFE_EXPRESSION) {
          const expressionCondition = condition as ExpressionCondition;

          // ExpressionCondition with "expression"
          if (typeof expressionCondition?.expression == 'string') {
            this.conditionEvaluationLogs += `Condition #${index}:\n`;

            const replacer = PfeRulesEvaluator.getReplacer(parsedJSON as PfeUserInputState);
            const jsonPathExpressions = expressionCondition.expression.match(JSON_PATH_REGEX)?.map((match) => match.slice(1, -1)) || [];
            this.conditionEvaluationLogs += jsonPathExpressions
              .map((jsonPathExpression: string) => `  - "${jsonPathExpression}" evaluates to ${replacer(jsonPathExpression)}\n`)
              .join('');

            const conditionsResult = this.pfeConditionsService.evaluateConditions(expressionCondition, parsedJSON);
            const evaluatedStatement = expressionCondition.expression.replace(JSON_PATH_REGEX, replacer);
            this.conditionEvaluationLogs += `\n  ${evaluatedStatement} => ${conditionsResult}\n\n`;
          }

          // ExpressionCondition with "value1Expression", "value2Expression" and "operator"
          else {
            this.logConditionWithOperator(expressionCondition, parsedJSON, index);
          }
          this.conditionEvaluationLogs += '----------------------------------------------------------------\n\n';
        }
      });
    }
  }

  logConditionWithOperator(expressionCondition: ExpressionCondition, parsedJSON: Record<string, unknown>, conditionIndex: number) {
    this.conditionEvaluationLogs += `Condition #${conditionIndex}:\n`;

    if (expressionCondition.value1Expression && expressionCondition.value2Expression && expressionCondition.operator) {
      const { value1Expression, value2Expression, operator } = expressionCondition;

      let evaluatedValue1Expression = value1Expression;
      let evaluatedValue2Expression = value2Expression;
      if (typeof value1Expression === 'string') {
        evaluatedValue1Expression = `"${PfeUtilService.getValueOrList(parsedJSON, value1Expression, true)}"`;
        this.conditionEvaluationLogs += `  - "${value1Expression}" evaluates to ${evaluatedValue1Expression}\n`;
      }
      if (typeof value2Expression === 'string') {
        evaluatedValue2Expression = `"${PfeUtilService.getValueOrList(parsedJSON, value2Expression, true)}"`;
        this.conditionEvaluationLogs += `  - "${value2Expression}" evaluates to ${evaluatedValue2Expression}\n`;
      }

      const conditionsResult = this.pfeConditionsService.evaluateConditions(expressionCondition, parsedJSON);
      this.conditionEvaluationLogs += `\n  ${evaluatedValue1Expression} ${operator} ${evaluatedValue2Expression} => ${conditionsResult}\n\n`;
      return conditionsResult;
    }
  }

  parseConditions() {
    try {
      if (this.jsonPathConditions) {
        this.jsonPathConditions = JSON.stringify(JSON.parse(this.jsonPathConditions), null, 2);
        this.conditionParseError = false;
      }
    } catch (e) {
      this.conditionParseError = true;
    }
  }

  parseJsonPathData() {
    try {
      if (this.jsonPathData) {
        this.jsonPathData = JSON.stringify(JSON.parse(this.jsonPathData), null, 2);
        this.jsonPathError = false;
      }
    } catch (e) {
      this.jsonPathError = true;
    }
  }

  loadExampleExpression() {
    this.jsonPathExpression = this.exampleExpression;
  }

  loadExampleExpressionCondition() {
    this.jsonPathConditions = this.exampleExpressionCondition;
  }

  loadExampleConditionAdvanced() {
    this.jsonPathConditions = this.exampleConditionAdvanced;
  }
}