import java.util.List;
import java.util.Set;
import java.util.HashMap;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class Classes
{
   private static final HashMap<String, Classes> FROM_ABBREVIATION;
   private static final HashMap<String, Classes> FROM_NAME;
   private static final String SEPARATOR = " ,.?-&:;";

   private final String name;
   private final String abbreviation;

   static
   {
      FROM_ABBREVIATION = new HashMap<String, Classes>();
      FROM_NAME = new HashMap<String, Classes>();
   }

   private Classes (final String name, final String abbreviation)
   {
      this.name = name;
      this.abbreviation = abbreviation;
   }

   private void register ()
   throws Classes.AlreadyRegisteredException
   {
      /**
       * We allow multiple (unique) names for the same class, but not
       * multiple abbreviations
       **/

      if (FROM_NAME.containsKey(name))
      {
         throw (new Classes.AlreadyRegisteredException());
      }

      if (!FROM_ABBREVIATION.containsKey(abbreviation))
      {
         FROM_ABBREVIATION.put(abbreviation, this);
      }

      FROM_NAME.put(name, this);
   }

   @Override
   public boolean equals (Object a)
   {
      if (a instanceof Classes)
      {
         return abbreviation.equals(((Classes) a).abbreviation);
      }

      return false;
   }

   @Override
   public String toString ()
   {
      return abbreviation;
   }

   public static String name_from_abbreviation (final String abbr)
   {
      final Classes c;

      c = FROM_ABBREVIATION.get(abbr);

      if (c == null)
      {
         return "unknown";
      }

      return c.name;
   }

   private static boolean word_is_isolated
   (
      final String word,
      final String sentence
   )
   {
      final int index_start, index_end;

      index_start = sentence.indexOf(word);

      if
      (
         (index_start == -1)
         || (index_start == 0)
         || (SEPARATOR.indexOf(sentence.charAt(index_start - 1)) == -1)
      )
      {
         return false;
      }

      index_end = (index_start + word.length());

      if (index_end == sentence.length())
      {
         return true;
      }

      return (SEPARATOR.indexOf(sentence.charAt(index_end)) != -1);
   }

   private static Classes ambiguous_entry_guard
   (
      final String entry,
      final String class_name
   )
   {
      final String rest_of_entry_name;
      boolean ambiguous;

      ambiguous = false;
      rest_of_entry_name = entry.substring(class_name.length());

      for (final String other_class_name: FROM_NAME.keySet())
      {
         if
         (
            !other_class_name.equals(class_name)
            && word_is_isolated(other_class_name, rest_of_entry_name)
            && !FROM_NAME.get(class_name).equals
               (
                  FROM_NAME.get(other_class_name)
               )
         )
         {
            final StringBuilder sb;

            sb = new StringBuilder();

            sb.append("Ambiguous event summary \"");
            sb.append(entry);
            sb.append("\". Starts with \"");
            sb.append(class_name);
            sb.append("\" (");
            sb.append(FROM_NAME.get(class_name));
            sb.append("), but also contains \"");
            sb.append(other_class_name);
            sb.append("\" (");
            sb.append(FROM_NAME.get(other_class_name));
            sb.append(")");

            Error.WARNING.from_file
            (
               Parameters.get_known_classes_filename(),
               sb.toString()
            );

            ambiguous = true;

            break;
         }
      }

      return ambiguous ? null : FROM_NAME.get(class_name);
   }
   public static String abbreviation_from_name
   (
      final String name,
      final boolean lazy
   )
   {
      Classes c;

      if (lazy)
      {
         c = null;

         for (final String n: FROM_NAME.keySet())
         {
            if (name.startsWith(n))
            {
               c = ambiguous_entry_guard(name, n);

               break;
            }
         }
      }
      else
      {
         c = FROM_NAME.get(name);
      }

      if (c == null)
      {
         return "unknown";
      }

      return c.abbreviation;
   }

   public static Set<String> get_all_abbreviations ()
   {
      return FROM_ABBREVIATION.keySet();
   }

   public static void read_all ()
   throws Exception
   {
      BufferedReader br;
      String input_line;
      String[] data;
      Classes new_class;

      br = null;

      try
      {
         br =
            new BufferedReader
            (
               new InputStreamReader
               (
                  new FileInputStream(Parameters.get_known_classes_filename())
               )
            );

         while ((input_line = br.readLine()) != null)
         {
            data = input_line.split("::");

            if (data.length != 3)
            {
               final StringBuilder sb;

               sb = new StringBuilder();

               sb.append("Invalid class entry: \"");
               sb.append(input_line);

               Error.ERROR.from_file
               (
                  Parameters.get_known_classes_filename(),
                  sb.toString()
               );

               continue;
            }

            new_class = new Classes(data[1], data[2]);

            if (!data[0].equals("") && FROM_ABBREVIATION.containsKey(data[2]))
            {
               final StringBuilder sb;

               sb = new StringBuilder();

               sb.append("Abbreviation \"");
               sb.append(data[2]);
               sb.append("\" is already in use.");

               Error.ERROR.from_file
               (
                  Parameters.get_known_classes_filename(),
                  sb.toString()
               );

               continue;
            }

            try
            {
               new_class.register();
            }
            catch (final Classes.AlreadyRegisteredException care)
            {
               final StringBuilder sb;

               sb = new StringBuilder();

               sb.append("Duplicate entry for class \"");
               sb.append(data[1]);
               sb.append("\".");

               Error.ERROR.from_file
               (
                  Parameters.get_known_classes_filename(),
                  sb.toString()
               );

               continue;
            }
         }
      }
      catch (final Exception e)
      {
         Error.FATAL.from_file
         (
            Parameters.get_known_classes_filename(),
            "Error while reading class file:",
            e.getMessage()
         );

         if (br != null)
         {
            try
            {
               br.close();
            }
            catch (final Exception e2)
            {
               Error.WARNING.from_file
               (
                  Parameters.get_known_classes_filename(),
                  "Error while closing class file:",
                  e2.getMessage()
               );
            }
         }

         throw e;
      }

      try
      {
         br.close();
      }
      catch (final Exception e)
      {
         Error.WARNING.from_file
         (
            Parameters.get_known_classes_filename(),
            "Error while closing class file:",
            e.getMessage()
         );

         throw e;
      }
   }

   private static class AlreadyRegisteredException extends Exception {}
}