import java.io.*;
import java.util.*;
import java.lang.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MAIN {
    
    
   /* this function is used to compare string values from two
    * separate text files. */
    
    public static void main(String[] args) {
        
        /* arraylists and hashsets */
        
        ArrayList registry_ratios = new ArrayList();
        ArrayList registry_uniques = new ArrayList();
        ArrayList registry_studies = new ArrayList();
        ArrayList results_ratios = new ArrayList();
        ArrayList results_studies = new ArrayList();
        ArrayList formularies = new ArrayList();
        ArrayList removal = new ArrayList();
        Set temp = new HashSet();
        HashMap results_uniques = new HashMap();
        
        try {
            BufferedReader in_one = new BufferedReader(new FileReader("registry.txt"));
            BufferedReader in_two = new BufferedReader(new FileReader("formularies.txt"));
            String registry_line;
            String formularies_line;
            
            /* separate each line, convert to uppercase and add to the arraylist */
            
            while ((registry_line = in_one.readLine()) != null) {
                registry_line = registry_line.toUpperCase();
                registry_ratios.add(registry_line);
            }
            while ((formularies_line = in_two.readLine()) != null) {
                formularies_line = formularies_line.toUpperCase();
                temp.add(formularies_line);
            }
            
            /* put the formularies back into an arraylist */
            
            for(Iterator it = temp.iterator(); it.hasNext(); ) {
                formularies.add(it.next());
            }
            
            /* we don't need the bufferedreader open anymore */
            
            in_one.close();
            in_two.close();
            
        } catch (IOException e) {
        }
        
        /* now do our comparisons */
        
        String regexp = null;
        Pattern pattern = null;
        Matcher matcher = null;
        
        for(int x=0;x<registry_ratios.size();x++) {
            for(int y=0;y<formularies.size();y++) {
                pattern = Pattern.compile("\\b" + Pattern.quote((String)formularies.get(y)) + "\\b");
                matcher = pattern.matcher((String)registry_ratios.get(x));
                if (matcher.find()) {
                    results_ratios.add(registry_ratios.get(x));
                    results_studies.add(registry_ratios.get(x));
                    break;
                }
            }
        }
        
        /* dupe check based on article ID # */
        
        for (int x=0; x<results_studies.size() - 1;x++) {
            if(((String) results_studies.get(x)).substring(9, 14).equals(((String) results_studies.get(x + 1)).substring(9, 14))) {
                removal.add(results_studies.get(x));
            }
        }
        
        for(Iterator it = removal.iterator(); it.hasNext(); ) {
            results_studies.remove(it.next());
        }
        
        removal.clear();
        
        /* create registry_studies */
        
        for(Iterator it = registry_ratios.iterator(); it.hasNext(); ) {
            registry_studies.add(it.next());
        }
        
        for (int x=0; x<registry_ratios.size() - 1;x++) {
            if(((String) registry_ratios.get(x)).substring(9, 14).equals(((String) registry_ratios.get(x + 1)).substring(9, 14))) {
                removal.add(registry_ratios.get(x));
            }
        }
        
        for(Iterator it = removal.iterator(); it.hasNext(); ) {
            registry_studies.remove(it.next());
        }
        
        removal.clear();
        
        /* uniques */
        
        /* create results_uniques */
        
        
      for(int x=0;x<results_studies.size();x++) {
        for(int y=0;y<formularies.size();y++) {
        if(((String)results_studies.get(x)).contains((String)formularies.get(y))) {
            if(!results_uniques.containsKey((String)formularies.get(y))) {
                results_uniques.put(formularies.get(y), results_studies.get(x));
            }
        }
        }
      }
        
               
                
        /* print results */
        
        for(Iterator it = results_studies.iterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }
        System.out.println("UNIQUE");
        Collection print_uniques = results_uniques.values();
        for(Iterator it = print_uniques.iterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }
        double formulary_size = formularies.size();
        double results_uniques_size = results_uniques.size();
        double ratio = results_uniques_size / formulary_size * 100;
        System.out.println("\n" + "REGISTRY DATA:" + "\n");
        System.out.println("# RATIO:" + " " + registry_ratios.size() + " " + "# STUDIES:" + " " + registry_studies.size() + " " + "# UNIQUE:" + " " + registry_uniques.size());
        System.out.println("\n" + "FORMULARY DATA:" + "\n");
        System.out.println("MATCHING # OF STUDIES:" + " " + results_studies.size());
        System.out.println("MATCHING # OF RATIOS:" + " " + results_ratios.size());
        System.out.println("MATCHING # OF UNIQUE DRUGS:" + " " + results_uniques.size());
        System.out.println("# OF DRUGS ON FORMULARY:" + " " + formularies.size());
        System.out.println("RATIO OF UNIQUE DRUGS/FORMULARY:" + " " + roundDouble(ratio,1) + "%" + "\n");
        
        /* clear the lists/sets */
        
        removal.clear();      
        registry_ratios.clear();
        registry_studies.clear();
        registry_uniques.clear();
        results_uniques.clear();
        results_ratios.clear();
        results_studies.clear();
        formularies.clear();
        temp.clear();
        
    }
    
    /* function used for rounding */
    
    public static final double roundDouble(double d, int places) {
        return Math.round(d * Math.pow(10, (double) places)) / Math.pow(10,
                (double) places);
    }
}