/*
    * Copyright 2011-2024 Medical Information Systems Research Group (https://medical.zcu.cz),
    * Department of Computer Science and Engineering, University of West Bohemia.
    * Address: Univerzitni 8, 306 14 Plzen, Czech Republic.
    *
    * Author Petr Vcelak (vcelak@kiv.zcu.cz).
    *
    * This file is part of AnonMed project.
    *
   * AnonMed is free software: you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation, either version 3 of the License.
   *
   * AnonMed is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with AnonMed. If not, see <http://www.gnu.org/licenses/>.
   */
  package cz.zcu.mre.anonmed.anonymizer;
  
  import cz.zcu.mre.anonmed.AnonMedConfiguration;
  import cz.zcu.mre.anonmed.AnonMedException;
  import cz.zcu.mre.anonmed.FilenameGenerator;
  import cz.zcu.mre.anonmed.report.AnonMedReport;
  import cz.zcu.mre.anonmed.rule.Operation;
  import cz.zcu.mre.anonmed.rule.Rule;
  import java.io.File;
  import java.io.IOException;
  import java.util.List;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Abstract de-identification class.
   *
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   * @since 2010-01-28
   */
  public abstract class AbstractAnonymizer implements Anonymizer {
  
      /**
       * Logger.
       */
      private static final Logger LOG = LoggerFactory.getLogger(AbstractAnonymizer.class);
  
      /**
       * Application configuration.
       */
      private AnonMedConfiguration config = null;
  
      /**
       * De-identification for a specific file type.
       */
      private String fileType = null;
  
      /**
       * De-identification file extension.
       */
      private String fileExtension = null;
  
      /**
       * Processed XML file.
       */
      private File activeFile = null;
  
      /**
       * Uncertain flag.
       */
      private Boolean uncertain = false;
  
      /**
       * The original file last modified time.
       */
      protected long originalLastModified = 0L;
  
      /**
       * An anonymous identification.
       */
      private String anonymousIdentification;
  
      /**
       * Abstract de-identification class.
       *
       * @param conf configuration.
       */
      public AbstractAnonymizer(final AnonMedConfiguration conf) {
          setConfig(conf);
      }
  
      /**
       * Set configuration.
       *
       * @param conf configuration.
       */
      protected final void setConfig(
              final AnonMedConfiguration conf) {
 
         if (conf == null) {
             throw new NullPointerException("Application config is null.");
         }
 
         this.config = conf;
     }
 
     /**
      * Get configuration.
      *
      * @return configuration.
      */
     @Override
     public final AnonMedConfiguration getConfig() {
         return config;
     }
 
     /**
      * Set file extension.
      *
      * @param extension file extension.
      */
     protected final void setFileExtension(
             final String extension) {
 
         this.fileExtension = extension;
     }
 
     /**
      * Get active (extracted) file that is processed.
      *
      * @return file actually extracted file.
      */
     public final File getActiveFile() {
 
         return activeFile;
     }
 
     /**
      * Set active (extracted) file that is processed.
      *
      * @param value active file.
      */
     protected final void setActiveFile(
             final File value) {
 
         this.activeFile = value;
 
         // update the original file last modified time
         if (value != null) {
             originalLastModified = value.lastModified();
         }
     }
 
     /**
      * Get file type as string.
      *
      * @return file type.
      */
     @Override
     public final String getFileType() {
 
         return this.fileType;
     }
 
     /**
      * Set file type as String.
      *
      * @param type file type
      */
     protected final void setFileType(
             final String type) {
 
         this.fileType = type;
     }
 
     /**
      * Has file uncertain status?
      *
      * @return true if uncertain
      */
     public final Boolean isUncertain() {
 
         return uncertain;
     }
 
     /**
      * Set uncertain flag.
      *
      * @param value Set true if uncertain, false otherwise.
      */
     protected final void setUncertain(
             final Boolean value) {
 
         this.uncertain = value;
     }
 
     /**
      * Create new de-identified file name. Filename is based on date and
      * sequence number.
      *
      * @return A new file name.
      */
     protected final String filenameGenerator() {
 
         String filename;
         String output = config.getOutputDirectory().getAbsolutePath();
 
         /* Use an uncertain directory as output when any UI method was used. */
         if (isUncertain()) {
             output = config.getUncertainDirectory().getAbsolutePath();
         }
 
         /* Set a new file name. */
         if (config.isChangeFilename()) {
             filename = FilenameGenerator.generateFileName()
                     .concat(".").concat(fileExtension);
         } else {
             filename = File.separator + activeFile.getName();
         }
 
         LOG.debug("OUTPUT in file {}", output.concat(filename));
 
         return output.concat(filename);
     }
 
     /**
      * De-identify file.
      *
      * @param file File for de-identification.
      * @return De-identified file.
      * @throws AnonMedException AnonMed exception.
      */
     @Override
     public final File anonymize(
             final File file)
             throws AnonMedException {
 
         fileOpen(file);
 
         if (getActiveFile() != null) {
 
             processRules();
 
             if (getConfig().isStrictMode()) {
                 strictMode();
             }
 
             String outputFileName = filenameGenerator();
             fileWrite(outputFileName);
 
             /* Set last last modified time */
             File anonymousFile = new File(outputFileName);
 
             if (!anonymousFile.setLastModified(originalLastModified)) {
                 LOG.error("ERROR Fail to change last modified time stamp {}", file.getAbsolutePath());
                 return null;
             }
 
             return anonymousFile;
         } else {
             LOG.error("ERROR Fail to anonymise file {}", file.getAbsolutePath());
         }
 
         return null;
     }
 
     /**
      * Process de-identification rules.
      */
     @Override
     public final void processRules() {
 
         List<Rule> profile = config.getProfileBuilder()
                 .getProfile(getFileType());
         if (profile == null) {
             LOG.error("No profile for ''{}'' file type.",
                     getFileType());
             return;
         }
 
         for (Rule r : profile) {
 
             switch (r.getOperation()) {
                 case APPEND_AFTER ->
                     ruleAppendAfter(r);
 
                 case APPEND_BEFORE ->
                     ruleAppendBefore(r);
 
                 case CHANGE ->
                     ruleChange(r);
 
                 case DECRYPT ->
                     ruleDecrypt(r);
 
                 case EMPTY ->
                     ruleEmpty(r);
 
                 case ENCRYPT ->
                     ruleEncrypt(r);
 
                 case EXTERNAL -> {
                     try {
                         ruleExternal(r);
                     } catch (AnonMedException e) {
                         LOG.error("Error during external application call: ", e);
                     }
                 }
 
                 case IDENTIFICATION ->
                     ruleIdentification(r);
 
                 case KEEP ->
                     ruleKeep(r);
 
                 case LOWERCASE ->
                     ruleLowercase(r);
 
                 case NONE ->
                     ruleNone(r);
 
                 case REMOVE ->
                     ruleRemove(r);
 
                 case SPECIFIC ->
                     ruleSpecific(r);
 
                 case SUBSTRING ->
                     ruleSubstring(r);
 
                 case SUBSTITUTE ->
                     ruleSubstitute(r);
 
                 case UPPERCASE ->
                     ruleUppercase(r);
 
                 default ->
                     LOG.error("Not supported requested operation {}", r.getOperation());
 
             }
         }
     }
 
     /**
      * You have to implement your own fileOpen method that is appropriate for
      * your data file format.
      *
      * @param file File to open.
      */
     @Override
     public abstract void fileOpen(final File file) throws AnonMedException;
 
     /**
      * You have to implement your own fileWrite method that is appropriate for
      * your data file format.
      *
      * @param filename fila name.
      * @throws AnonMedException exception when fail.
      */
     @Override
     public abstract void fileWrite(final String filename) throws AnonMedException;
 
     /**
      * Rule external application call.
      *
      * @param rule Rule
      * @throws AnonMedException exception when exit code wasn't zero.
      */
     @Override
     public final void ruleExternal(final Rule rule) throws AnonMedException {
 
         try {
             Process p = Runtime.getRuntime().exec(
                     rule.getRule() + " " + getActiveFile()
                     + " " + rule.getNewValue());
 
             if (p.exitValue() != 0) {
                 throw new AnonMedException(p.exitValue());
             }
 
         } catch (IOException e) {
             LOG.error(null, e);
         }
     }
 
     /**
      * The rule KEEP method is empty. It does nothing because it is used for
      * building KEEP list only by the buildStrictList.
      *
      * @param rule Rule keep.
      */
     @Override
     public void ruleKeep(final Rule rule) {
 
         /* Keep rule is used as a marker only. */
     }
 
     /**
      * Do nothing rule.
      *
      * @param rule Rule none.
      */
     @Override
     public void ruleNone(final Rule rule) {
 
         /* Rule 'NONE' does nothing and does it excellently. */
     }
 
     /**
      * Look for the rule for specified tag/path/etc. in the profile.
      *
      * @param rule Rule to find out.
      * @return Result. It is true when it is on the strict mode list of allowed
      * tags/elements/paths/etc.
      */
     @Override
     public final Boolean isStrictModeRemove(final String rule) {
 
         List<Rule> profile
                 = config.getProfileBuilder().getProfile(getFileType());
 
         for (Rule r : profile) {
 
             if (testForSameRule(r.getRule(), rule)
                     && (r.getOperation() == Operation.CHANGE
                     || r.getOperation() == Operation.EMPTY
                     || r.getOperation() == Operation.IDENTIFICATION
                     || r.getOperation() == Operation.KEEP
                     || r.getOperation() == Operation.ENCRYPT)) {
                 return Boolean.FALSE;
             }
         }
 
         return Boolean.TRUE;
     }
 
     /**
      * Test the same rule.
      *
      * @param rule1 Rule 1
      * @param rule2 Rule 2
      * @return Result is true when it equals.
      */
     private Boolean testForSameRule(final String rule1, final String rule2) {
 
         if (rule1.equals(rule2)) {
             return Boolean.TRUE;
         }
 
         return Boolean.FALSE;
     }
 
     /**
      * Encrypt content by the configured CipherService.
      *
      * @param rule The rule.
      * @param oldValue Source text content.
      * @return Encrypted text.
      */
     protected String makeEncrypt(final Rule rule, final String oldValue) {
 
         if (rule == null) {
             throw new IllegalArgumentException("The rule cannot be null");
         }
 
         String value = rule.getNewValue();
         if (value == null || value.isEmpty()) {
             throw new IllegalArgumentException("Missing or wrong argument(s) for ENCRYPT operation");
         }
 
         String[] settings = value.split(",");
         switch (settings.length) {
             case 0 ->
                 throw new IllegalArgumentException("Missing argument for ENCRYPT operation");
             case 1 -> {
                 // aes/rsa
                 String alg = settings[0].trim().toLowerCase();
                 // the key alias is person/patient/thing ID dependent
                 String alias = getAnonymousIdentification();
 
                 LOG.debug("Use encrypt algorithm {} and key with alias {}", alg, alias);
                 return config.getCipherService().encrypt(alg, oldValue, alias);
             }
             case 2 -> {
                 // aes/rsa
                 String alg = settings[0].trim().toLowerCase();
                 // key alias is the second argument
                 String alias = settings[1].trim().toLowerCase();
 
                 LOG.debug("Use encrypt algorithm {} and key with alias {}", alg, alias);
                 return config.getCipherService().encrypt(alg, oldValue, alias);
             }
             default ->
                 throw new IllegalArgumentException("Only two arguments are allowed per ENCRYPT rule");
         }
     }
 
     /**
      * Decrypt content by the configured CipherService.
      *
      * @param rule The rule.
      * @param encrypted Encrypted text.
      * @return Decrypted text content.
      */
     protected String makeDecrypt(final Rule rule, String encrypted) {
 
         if (rule == null) {
             throw new IllegalArgumentException("The rule cannot be null");
         }
 
         String value = rule.getNewValue();
         if (value == null || value.isEmpty()) {
             throw new IllegalArgumentException("Missing or wrong argument(s) for ENCRYPT operation");
         }
 
         String[] settings = value.split(",");
 
         switch (settings.length) {
             case 0 ->
                 throw new IllegalArgumentException("Missing argument for ENCRYPT operation");
             case 1 -> {
                 // aes/rsa
                 String alg = settings[0].trim().toLowerCase();
                 // the key alias is person/patient/thing ID dependent
                 String alias = getAnonymousIdentification();
 
                 LOG.debug("Use decrypt algorithm {} and key with alias {}", alg, alias);
                 return config.getCipherService().decrypt(alg, encrypted, alias);
 
             }
             case 2 -> {
                 // aes/rsa
                 String alg = settings[0].trim().toLowerCase();
                 // key alias is the second argument
                 String alias = settings[1].trim().toLowerCase();
 
                 LOG.debug("Use decrypt algorithm {} and key with alias {}", alg, alias);
                 return config.getCipherService().decrypt(alg, encrypted, alias);
             }
             default ->
                 throw new IllegalArgumentException("Only two arguments are allowed per ENCRYPT rule");
         }
     }
 
     /**
      * Make report output.
      *
      * @param rule The active rule.
      * @param oldValue The old value.
      * @param newValue The new value.
      */
     protected void report(Rule rule, String oldValue, String newValue) {
         AnonMedReport.add(activeFile, rule, oldValue, newValue);
     }
 
     /**
      *
      * Replace value in a sed-like manner: 's#REGEX#REPLACEMENT#FLAGS'.
      *
      * @param rule The rule.
      * @param oldValue Old value.
      * @return New string value.
      */
     protected String makeSubstitute(Rule rule, String oldValue) {
 
         if (rule == null || oldValue == null || oldValue.isEmpty()) {
             LOG.debug("Empty or null value for SUBSTITUTE {}", rule);
             return "";
         }
 
         // use rule config
         String ruleValue = rule.getNewValue();
         if (ruleValue != null && !ruleValue.isEmpty()) {
             String[] conf = ruleValue.split("#");
 
             switch (conf.length) {
                 case 2 -> {
                     return oldValue.replaceFirst(conf[0], conf[1]);
                 }
 
                 case 3 -> {
                     if (conf[2].equals("g")) {
                         // global
                         return oldValue.replaceAll(conf[0], conf[1]);
                     } else {
                         return oldValue.replaceFirst(conf[0], conf[1]);
                     }
                 }
 
                 default ->
                     LOG.debug("Wrong parameters (e.g. missing '#' separator) for SUBSTITUTE {}", rule);
             }
         }
 
         return oldValue;
     }
 
     /**
      * Get and use makeSubstring with start and end positions in the value.
      *
      * @param rule The rule.
      * @param oldValue Old value.
      * @return New string value.
      */
     protected String makeSubstring(Rule rule, String oldValue) {
 
         if (rule == null || oldValue == null || oldValue.isEmpty()) {
             return "";
         }
 
         // initialise variables
         int beginIndex = 0; // set minimum
         int endIndex = oldValue.length(); // set maximum
 
         // use rule config
         String ruleValue = rule.getNewValue();
         if (ruleValue != null) {
             String[] conf = ruleValue.split(",");
 
             switch (conf.length) {
                 case 0 -> {
                     LOG.error("Missing configuration for the SUBSTRING {}", rule);
                     return oldValue;
                 }
                 case 1 -> {
                     try {
                         beginIndex = Integer.parseInt(conf[0]);
                         return oldValue.substring(beginIndex);
                     } catch (NumberFormatException ex) {
                         LOG.error("Wrong substring number in the rule {}", rule);
                     }
                 }
                 case 2 -> {
                     // parse beginIndex
                     if (conf[0].equals("MIN")) {
                         beginIndex = 0;
                     } else {
                         try {
                             beginIndex = Integer.parseInt(conf[0]);
                         } catch (NumberFormatException ex) {
                             LOG.error("Wrong substring number in the rule {}", rule);
                         }
                     }
 
                     // parse endIndex
                     if (conf[1].equals("MAX")) {
                         endIndex = oldValue.length();
                     } else {
                         try {
                             endIndex = Integer.parseInt(conf[1]);
                         } catch (NumberFormatException ex) {
                             LOG.error("Wrong substring number in the rule {}", rule);
                         }
                     }
                 }
                 default -> {
                     LOG.error("The rule configuration should have two arguments - numbers, MIN or MAX string instead. Wrong parameters for substring: {}", rule);
                 }
             }
         }
 
         // fix wrong indexes
         if (beginIndex < 0) {
             beginIndex = 0;
         }
         if (endIndex > oldValue.length()) {
             endIndex = oldValue.length();
         }
         return oldValue.substring(beginIndex, endIndex);
     }
 
     /**
      * Change text to lowercase letters.
      *
      * @param rule The rule.
      * @param oldValue Old value.
      * @return New string value.
      */
     protected String makeLowercase(Rule rule, String oldValue) {
 
         return oldValue.toLowerCase();
     }
 
     /**
      * Change text to lowercase letters.
      *
      * @param rule The rule.
      * @param oldValue Old value.
      * @return New string value.
      */
     protected String makeUppercase(Rule rule, String oldValue) {
 
         return oldValue.toUpperCase();
     }
 
     @Override
     public String getAnonymousIdentification() {
         return anonymousIdentification;
     }
 
     protected void setAnonymousIdentification(String anonymousIdentification) {
         this.anonymousIdentification = anonymousIdentification;
     }
 
 }