import {AbilitiesType, AnyJson} from "~/types/types";
import * as _ from "lodash";

const roles_by_function = [
  'ROLE_SUPER_ADMIN',
  'ROLE_ADMIN',
  'ROLE_ADMIN_CORE',
  'ROLE_ADMINISTRATIF_MANAGER',
  'ROLE_ADMINISTRATIF_MANAGER_CORE',
  'ROLE_PEDAGOGICS_MANAGER',
  'ROLE_PEDAGOGICS_MANAGER_CORE',
  'ROLE_FINANCIAL_MANAGER',
  'ROLE_FINANCIAL_MANAGER_CORE',
  'ROLE_CA',
  'ROLE_CA_CORE',
  'ROLE_STUDENT',
  'ROLE_STUDENT_CORE',
  'ROLE_TEACHER',
  'ROLE_TEACHER_CORE',
  'ROLE_MEMBER',
  'ROLE_MEMBER_CORE',
  'ROLE_OTHER',
  'ROLE_OTHER_CORE'
];

const roles_to_change = [
  'ROLE_GENERAL_CONFIG',
  'ROLE_GENERAL_CONFIG_VIEW',
  'ROLE_TAGG_ADVANCED',
  'ROLE_TAGG_ADVANCED_VIEW',
  'ROLE_PEDAGOGICS_ADMINISTRATION',
  'ROLE_PEDAGOGICS_ADMINISTRATION_VIEW',
  'ROLE_PEDAGOGICS_SEIZURE',
  'ROLE_PEDAGOGICS_SEIZURE_VIEW',
  'ROLE_BILLINGS_ADMINISTRATION',
  'ROLE_BILLINGS_ADMINISTRATION_VIEW',
  'ROLE_BILLINGS_SEIZURE',
  'ROLE_BILLINGS_SEIZURE_VIEW',
  'ROLE_ONLINEREGISTRATION_ADMINISTRATION',
  'ROLE_ONLINEREGISTRATION_ADMINISTRATION_VIEW'
];

const action_map: AnyJson = {
  '': 'manage',
  '_VIEW': 'read'
}

/**
 * @category Services/droits
 * @class RoleUtils
 * Classe permettant de mener des opérations sur les roles
 */
class RoleUtils {

  /**
   * @constructor
   */
  constructor() {
  }

  /**
   * Test si une personne possède le role lui permettant d'acquérir la fonction
   * @param {string} function_name
   * @param {Array<string>} roles
   * @returns {boolean}
   */
  isA(function_name:string, roles:Array<string>): boolean {
    return roles.indexOf('ROLE_' + function_name + '_CORE') >= 0
  }

  /**
   * Filtre les roles afin d'en exclure les "Roles fonctions"
   * @param {Array<string>} roles
   * @returns {Array<string>}
   */
  filterFunctionRoles(roles:Array<string>):Array<string>{
    return roles.filter(role => {
      return roles_by_function.indexOf(role) < 0
    })
  }

  /**
   * Avant la migration complète, quelque role disposent d'underscore en trop, on corrige cela...
   * @param {Array<string>} roles
   * @returns {Array<string>}
   */
  transformUnderscoreToHyphenBeforeCompleteMigration(roles: Array<string>): Array<string> {
    const regex = /(ROLE\_)([A-Z]*\_[A-Z]*)([A-Z\_]*)*/i;
    let match;
    roles = roles.map((role) => {
      if (roles_to_change.indexOf(role) >= 0) {
        if ((match = regex.exec(role)) !== null) {
          let role = match[1]
          let subject = match[2].replace('_', '-')
          let action = match[3]
          return role + subject + (action ? action : '')
        }
      }
      return role;
    });
    return roles
  }

  /**
   * On transforme les ROLES Symfony en Abilities
   * @param {Array<string>} roles
   * @returns {Array<AbilitiesType>}
   */
  transformRoleToAbilities(roles: Array<string>): [] | Array<AbilitiesType> {
    let abilities:any = [];

    const regex = /(ROLE\_)([A-Z\-]*)([\_A-Z]*)/i;
    let match;

    _.each(roles, role =>{
      if ((match = regex.exec(role)) !== null) {
        let subject = match[2]
        let action = match[3]
        abilities.push({
          action: action_map[action],
          subject: subject.toLowerCase()
        })
      }
    })

    return abilities;
  }
}

export const $roleUtils = new RoleUtils();