/*
    * 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;
  
  import cz.zcu.mre.anonmed.rule.ProfileBuilder;
  import cz.zcu.mre.mrelib.cipher.CipherService;
  import java.io.File;
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * Look for anonymous identification in an external source file.
   *
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   * @since 2011-03-09
   */
  public final class AnonMedConfiguration {
  
      /**
       * AnonMed principal text.
       */
      public static final String ANONMED_X500_PRINCIPAL
              = "CN=AnonMed, OU=medical.zcu.cz, O=ZCU, C=CS";
  
      /**
       * Default AnonMed password.
       */
      private static final String DEFAULT_PASSWORD = "AnonMed";
      /**
       * Change file name.
       */
      private Boolean changeFilename = false;
      /**
       * Remove original file when de-identification is complete.
       */
      private Boolean deleteOriginal = false;
      /**
       * Overwrite original. Original file is modified.
       */
      private Boolean overwriteFile = false;
      /**
       * Strict mode feature.
       */
      private Boolean strictMode = false;
      /**
       * List of all files for processing.
       */
      private List<File> inputFiles = new ArrayList<>();
      /**
       * Output directory.
       */
      private File outputDirectory = null;
      /**
       * Profiles for medical data types.
       */
      private ProfileBuilder profileBuilder = null;
      /**
       * Output directory for files that are uncertain.
       */
      private File uncertainDirectory = null;
  
      /**
       * Directory with key stores.
       */
      private File keystoresDirectory = null;
  
      private String password = DEFAULT_PASSWORD;
      /**
       * Cipher service.
       */
      private CipherService cipherService = null;
  
      private String context = null;
  
      /**
       * Is changing file name allowed.
       *
       * @return True if it is allowed.
       */
      public Boolean isChangeFilename() {
         return changeFilename;
     }
 
     /**
      * Set if change file name is allowed.
      *
      * @param value True if it is allowed to change the file name.
      */
     public void setChangeFilename(final Boolean value) {
         this.changeFilename = value;
     }
 
     /**
      * Should original be deleted?
      *
      * @return True if it is allowed.
      */
     public Boolean isDeleteOriginal() {
         return deleteOriginal;
     }
 
     /**
      * Set if original file deletion is allowed.
      *
      * @param delete set true if original file have to be deleted.
      */
     public void setDeleteOriginal(final Boolean delete) {
         this.deleteOriginal = delete;
     }
 
     /**
      * Should the original file be overwritten?
      *
      * @return True if it is allowed.
      */
     public Boolean isOverwriteFile() {
         return overwriteFile;
     }
 
     /**
      * Set if original file should be overwritten.
      *
      * @param overwrite True if it is allowed/requested.
      */
     public void setOverwriteFile(final Boolean overwrite) {
         this.overwriteFile = overwrite;
     }
 
     /**
      * Is strict mode enabled?
      *
      * @return True if strict mode is enabled.
      */
     public Boolean isStrictMode() {
         return strictMode;
     }
 
     /**
      * Set strict mode.
      *
      * @param strict True if this mode is requested.
      */
     public void setStrictMode(final Boolean strict) {
         this.strictMode = strict;
     }
 
     /**
      * Get input files list.
      *
      * @return input files list.
      */
     public List<File> getInputFiles() {
         return inputFiles;
     }
 
     /**
      * Set input files.
      *
      * @param files input files.
      */
     public void setInputFiles(final List<File> files) {
         this.inputFiles = files;
     }
 
     /**
      * Get output directory.
      *
      * @return output directory.
      */
     public File getOutputDirectory() {
         return outputDirectory;
     }
 
     /**
      * Set output directory.
      *
      * @param output output directory.
      */
     public void setOutputDirectory(final File output) {
 
         if (!output.exists()
                 || !output.isDirectory()
                 || !output.canWrite()) {
             throw new AnonMedException("Output directory "
                     + output.getAbsolutePath()
                     + " does not exist, it is not a directory "
                     + "or permission to write is missing.", -1);
         }
         this.outputDirectory = output;
     }
 
     /**
      * Get profile builder.
      *
      * @return profile builder.
      */
     public ProfileBuilder getProfileBuilder() {
         return profileBuilder;
     }
 
     /**
      * Get profile or rules builder.
      *
      * @param builder profile/rules builder.
      */
     public void setProfileBuilder(final ProfileBuilder builder) {
         this.profileBuilder = builder;
     }
 
     /**
      * Get uncertain directory.
      *
      * @return uncertain directory.
      */
     public File getUncertainDirectory() {
         return uncertainDirectory;
     }
 
     /**
      * Set uncertain directory.
      *
      * @param dir uncertain directory.
      */
     public void setUncertainDirectory(final File dir) {
 
         if (!dir.exists() || !dir.isDirectory() || !dir.canWrite()) {
             throw new AnonMedException("Uncertain output directory "
                     + dir.getAbsolutePath()
                     + " does not exist, it is not a directory "
                     + "or permission to write is missing.", -1);
         }
 
         this.uncertainDirectory = dir;
     }
 
     /**
      * Set directory for key stores.
      *
      * @param directory output directory.
      */
     public void setKeystoresDirectory(final File directory) {
 
         if (!directory.exists()
                 || !directory.isDirectory()
                 || !directory.canWrite()) {
             throw new AnonMedException("KeyStore directory "
                     + directory.getAbsolutePath()
                     + " does not exist, it is not a directory "
                     + "or permission to write is missing.", -1);
         }
         this.keystoresDirectory = directory;
     }
 
     public File getKeystoresDirectory() {
         return keystoresDirectory;
     }
 
     public CipherService getCipherService() {
         return cipherService;
     }
 
     public void setCipherService(CipherService cipherService) {
         this.cipherService = cipherService;
     }
 
     public String getPassword() {
         return password;
     }
 
     public void setPassword(String password) {
         this.password = password;
     }
 
     public void setContext(String context) {
         this.context = context;
     }
 
     public String getContext() {
         return context;
     }
 
 }