ConceptPortal-public/rsconcept/frontend/src/hooks/useCheckExpression.ts

'use client';

import { useCallback, useState } from 'react';

import { type ErrorData } from '@/components/InfoError';
import { CstType, IConstituenta, type IRSForm } from '@/models/rsform';
import { IArgumentInfo,IExpressionParse } from '@/models/rslang';
import { RSErrorType } from '@/models/rslang';
import { DataCallback, postCheckExpression } from '@/utils/backendAPI';
import { getCstExpressionPrefix } from '@/utils/misc';

const LOGIC_TYPIIFCATION = 'LOGIC';

function useCheckExpression({ schema }: { schema?: IRSForm }) {
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<ErrorData>(undefined);
  const [parseData, setParseData] = useState<IExpressionParse | undefined>(undefined);

  const resetParse = useCallback(() => setParseData(undefined), []);

  function checkExpression(expression: string, activeCst?: IConstituenta, onSuccess?: DataCallback<IExpressionParse>) {
    setError(undefined);
    postCheckExpression(String(schema!.id), {
      data: { expression: expression },
      showError: true,
      setLoading,
      onError: error => setError(error),
      onSuccess: parse => {
        if (activeCst) {
          adjustResults(parse, expression.trim() === getCstExpressionPrefix(activeCst), activeCst.cst_type);
        }
        setParseData(parse);
        if (onSuccess) onSuccess(parse);
      }
    });
  }

  return { parseData, checkExpression, resetParse, error, setError, loading };
}

export default useCheckExpression;

// ===== Internals ========

function checkTypeConsistency(type: CstType, typification: string, args: IArgumentInfo[]): boolean {
  switch (type) {
  case CstType.BASE:
  case CstType.CONSTANT:
  case CstType.STRUCTURED:
  case CstType.TERM:
    return typification !== LOGIC_TYPIIFCATION && args.length === 0;

  case CstType.AXIOM:
  case CstType.THEOREM:
    return typification === LOGIC_TYPIIFCATION && args.length === 0;

  case CstType.FUNCTION:
    return typification !== LOGIC_TYPIIFCATION && args.length !== 0;

  case CstType.PREDICATE:
    return typification === LOGIC_TYPIIFCATION && args.length !== 0;
  }
}

function adjustResults(parse: IExpressionParse, emptyExpression: boolean, cstType: CstType) {
  if (!parse.parseResult && parse.errors.length > 0) {
    return;
  }
  if (cstType === CstType.BASE || cstType === CstType.CONSTANT) {
    if (!emptyExpression) {
      parse.parseResult = false;
      parse.errors.push({
        errorType: RSErrorType.globalNonemptyBase,
        isCritical: true,
        params: [],
        position: 0
      });
    }
  } else {
    if (emptyExpression) {
      parse.parseResult = false;
      parse.errors.push({
        errorType: RSErrorType.globalEmptyDerived,
        isCritical: true,
        params: [],
        position: 0
      });
    }
  }
  if (!checkTypeConsistency(cstType, parse.typification, parse.args)) {
    parse.parseResult = false;
    parse.errors.push({
      errorType: RSErrorType.globalUnexpectedType,
      isCritical: true,
      params: [],
      position: 0
    });
  }
}