// Current user info
export interface ICurrentUser {
  id: number
  username: string
  is_staff: boolean
}

// User profile data
export interface IUserProfile {
  id: number
  username: string
  email: string
  first_name: string
  last_name: string
}

// User base info
export interface IUserInfo {
  id: number
  username: string
  first_name: string
  last_name: string
}

// User data for signup
export interface IUserSignupData {
  username: string
  email: string
  first_name: string
  last_name: string
  password: string
  password2: string
}

// User data for signup
export interface INewCstData {
  alias: string
  csttype: CstType
  insert_after?: number
}

// Constituenta type
export enum CstType {
  BASE = 'basic',
  CONSTANT = 'constant',
  STRUCTURED = 'structure',
  AXIOM = 'axiom',
  TERM = 'term',
  FUNCTION = 'function',
  PREDICATE = 'predicate',
  THEOREM = 'theorem'
}

// ValueClass
export enum ValueClass {
  INVALID = 'invalid',
  VALUE = 'value',
  PROPERTY = 'property'
}

// Syntax
export enum Syntax {
  UNDEF = 'undefined',
  ASCII = 'ascii',
  MATH = 'math'
}

// ParsingStatus
export enum ParsingStatus {
  UNDEF = 'undefined',
  VERIFIED = 'verified',
  INCORRECT = 'incorrect'
}

// Constituenta data
export interface IConstituenta {
  id: number
  alias: string
  cstType: CstType
  convention?: string
  term?: {
    raw: string
    resolved?: string
    forms?: string[]
  }
  definition?: {
    formal: string
    text: {
      raw: string
      resolved?: string
    }
  }
  parse?: {
    status: ParsingStatus
    valueClass: ValueClass
    typification: string
    syntaxTree: string
  }
}

// RSForm stats
export interface IRSFormStats {
  count_all: number
  count_errors: number
  count_property: number
  count_incalc: number

  count_termin: number

  count_base: number
  count_constant: number
  count_structured: number
  count_axiom: number
  count_term: number
  count_function: number
  count_predicate: number
  count_theorem: number
}

// RSForm data
export interface IRSForm {
  id: number
  title: string
  alias: string
  comment: string
  is_common: boolean
  time_create: string
  time_update: string
  owner?: number
  items?: IConstituenta[]
  stats?: IRSFormStats
}

// RSForm user input
export interface IRSFormCreateData {
  title: string
  alias: string
  comment: string
  is_common: boolean
  file?: File
}

//! RS language token types enumeration
export enum TokenID {
  // Global, local IDs and literals
  ID_LOCAL = 258,
  ID_GLOBAL,
  ID_FUNCTION,
  ID_PREDICATE,
  ID_RADICAL,
  LIT_INTEGER,
  LIT_INTSET,
  LIT_EMPTYSET,

  // Aithmetic
  PLUS,
  MINUS,
  MULTIPLY,

  // Integer predicate symbols
  GREATER,
  LESSER,
  GREATER_OR_EQ,
  LESSER_OR_EQ,

  // Equality comparison
  EQUAL,
  NOTEQUAL,

  // Logic predicate symbols
  FORALL,
  EXISTS,
  NOT,
  EQUIVALENT,
  IMPLICATION,
  OR,
  AND,

  // Set theory predicate symbols
  IN,
  NOTIN,
  SUBSET,
  SUBSET_OR_EQ,
  NOTSUBSET,

  // Set theory operators
  DECART,
  UNION,
  INTERSECTION,
  SET_MINUS,
  SYMMINUS,
  BOOLEAN,

  // Structure operations
  BIGPR,
  SMALLPR,
  FILTER,
  CARD,
  BOOL,
  DEBOOL,
  REDUCE,

  // Term constructions prefixes
  DECLARATIVE,
  RECURSIVE,
  IMPERATIVE,

  // Punctuation
  PUNC_DEFINE,
  PUNC_STRUCT,
  PUNC_ASSIGN,
  PUNC_ITERATE,
  PUNC_PL,
  PUNC_PR,
  PUNC_CL,
  PUNC_CR,
  PUNC_SL,
  PUNC_SR,
  PUNC_BAR,
  PUNC_COMMA,
  PUNC_SEMICOLON,

  // ======= Non-terminal tokens =========
  NT_ENUM_DECL, // Перечисление переменных в кванторной декларации
  NT_TUPLE, // Кортеж (a,b,c), типизация B(T(a)xT(b)xT(c))
  NT_ENUMERATION, // Задание множества перечислением
  NT_TUPLE_DECL, // Декларация переменных с помощью кортежа
  NT_ARG_DECL, // Объявление аргумента

  NT_FUNC_DEFINITION, // Определение функции
  NT_ARGUMENTS, // Задание аргументов функции
  NT_FUNC_CALL, // Вызов функции

  NT_DECLARATIVE_EXPR, // Задание множества с помощью выражения D{x из H | A(x) }
  NT_IMPERATIVE_EXPR, // Императивное определение
  NT_RECURSIVE_FULL, // Полная рекурсия
  NT_RECURSIVE_SHORT, // Сокращенная рекурсия

  NT_IMP_DECLARE, // Блок декларации
  NT_IMP_ASSIGN, // Блок присвоения
  NT_IMP_LOGIC, // Блок проверки

  // ======= Helper tokens ========
  INTERRUPT,
  END,
};

// Constituenta edit mode
export enum EditMode {
  TEXT = 'text',
  RSLANG = 'rslang'
}

// RSExpression status
export enum ExpressionStatus {
  UNDEFINED = 0,
  UNKNOWN,
  INCORRECT,
  INCALCULABLE,
  PROPERTY,
  VERIFIED
}

export function inferStatus(parse?: ParsingStatus, value?: ValueClass): ExpressionStatus {
  if (!parse || !value) {
    return ExpressionStatus.UNDEFINED;
  }
  if (parse === ParsingStatus.UNDEF) {
    return ExpressionStatus.UNKNOWN;
  }
  if (parse === ParsingStatus.INCORRECT) {
    return ExpressionStatus.INCORRECT;
  }
  if (value === ValueClass.INVALID) {
    return ExpressionStatus.INCALCULABLE;
  }
  if (value === ValueClass.PROPERTY) {
    return ExpressionStatus.PROPERTY;
  }
  return ExpressionStatus.VERIFIED
}

export function CalculateStats(schema: IRSForm) {
  if (!schema.items) {
    schema.stats = {
      count_all: 0,
      count_errors: 0,
      count_property: 0,
      count_incalc: 0,

      count_termin: 0,

      count_base: 0,
      count_constant: 0,
      count_structured: 0,
      count_axiom: 0,
      count_term: 0,
      count_function: 0,
      count_predicate: 0,
      count_theorem: 0
    }
    return;
  }
  schema.stats = {
    count_all: schema.items?.length || 0,
    count_errors: schema.items?.reduce(
      (sum, cst) => sum + (cst.parse?.status === ParsingStatus.INCORRECT ? 1 : 0) || 0, 0),
    count_property: schema.items?.reduce(
      (sum, cst) => sum + (cst.parse?.valueClass === ValueClass.PROPERTY ? 1 : 0) || 0, 0),
    count_incalc: schema.items?.reduce(
      (sum, cst) => sum +
      ((cst.parse?.status === ParsingStatus.VERIFIED && cst.parse?.valueClass === ValueClass.INVALID) ? 1 : 0) || 0, 0),

    count_termin: schema.items?.reduce(
      (sum, cst) => (sum + (cst.term?.raw ? 1 : 0) || 0), 0),

    count_base: schema.items?.reduce(
      (sum, cst) => sum + (cst.cstType === CstType.BASE ? 1 : 0), 0),
    count_constant: schema.items?.reduce(
      (sum, cst) => sum + (cst.cstType === CstType.CONSTANT ? 1 : 0), 0),
    count_structured: schema.items?.reduce(
      (sum, cst) => sum + (cst.cstType === CstType.STRUCTURED ? 1 : 0), 0),
    count_axiom: schema.items?.reduce(
      (sum, cst) => sum + (cst.cstType === CstType.AXIOM ? 1 : 0), 0),
    count_term: schema.items?.reduce(
      (sum, cst) => sum + (cst.cstType === CstType.TERM ? 1 : 0), 0),
    count_function: schema.items?.reduce(
      (sum, cst) => sum + (cst.cstType === CstType.FUNCTION ? 1 : 0), 0),
    count_predicate: schema.items?.reduce(
      (sum, cst) => sum + (cst.cstType === CstType.PREDICATE ? 1 : 0), 0),
    count_theorem: schema.items?.reduce(
      (sum, cst) => sum + (cst.cstType === CstType.THEOREM ? 1 : 0), 0)
  }
}

export function matchConstituenta(query: string, target?: IConstituenta) {
  if (!target) {
    return false;
  } else if (target.alias.match(query)) {
    return true;
  } else if (target.term?.resolved?.match(query)) {
    return true;
  } else if (target.definition?.formal.match(query)) {
    return true;
  } else if (target.definition?.text.resolved?.match(query)) {
    return true;
  } else if (target.convention?.match(query)) {
    return true;
  } else {
    return false;
  }
}